implement some TODOs, add malloc checks and logging
r1984 | dcl | 2007-05-25 16:12:10 +1000 (Fri, 25 May 2007) | 2 lines
This commit is contained in:
Douglas Clowes
@ -48,7 +48,7 @@ int defaultHandleInput(pAsyncProtocol p, pAsyncTxn txn, int ch) {
|
||||
}
|
||||
|
||||
int defaultHandleEvent(pAsyncProtocol p, pAsyncTxn txn, int event) {
|
||||
/* TODO: handle the event */
|
||||
/* TODO: what could or should we do to handle the event */
|
||||
return AQU_POP_CMD;
|
||||
}
|
||||
|
||||
@ -73,12 +73,20 @@ int defaultPrepareTxn(pAsyncProtocol p, pAsyncTxn txn, const char* cmd, int cmd_
|
||||
if (term[state] == 0) {
|
||||
/* outgoing command is correctly terminated */
|
||||
txn->out_buf = malloc(cmd_len + 1);
|
||||
if (txn->out_buf == NULL) {
|
||||
SICSLogWrite("Out of memory in AsyncProtocol::defaultPrepareTxn", eError);
|
||||
return 0;
|
||||
}
|
||||
memcpy(txn->out_buf, cmd, cmd_len + 1);
|
||||
}
|
||||
else {
|
||||
/* outgoing command is NOT correctly terminated */
|
||||
int tlen = strlen(term);
|
||||
txn->out_buf = malloc(cmd_len + tlen + 1);
|
||||
if (txn->out_buf == NULL) {
|
||||
SICSLogWrite("Out of memory in AsyncProtocol::defaultPrepareTxn", eError);
|
||||
return 0;
|
||||
}
|
||||
memcpy(txn->out_buf, cmd, cmd_len);
|
||||
memcpy(txn->out_buf + cmd_len, term, tlen + 1);
|
||||
cmd_len += tlen;
|
||||
@ -86,6 +94,12 @@ int defaultPrepareTxn(pAsyncProtocol p, pAsyncTxn txn, const char* cmd, int cmd_
|
||||
txn->out_len = cmd_len;
|
||||
txn->out_idx = 0;
|
||||
txn->inp_buf = malloc(rsp_len);
|
||||
if (txn->inp_buf == NULL) {
|
||||
SICSLogWrite("Out of memory in AsyncProtocol::defaultPrepareTxn", eError);
|
||||
free(txn->out_buf);
|
||||
txn->out_buf = NULL;
|
||||
return 0;
|
||||
}
|
||||
txn->inp_len = rsp_len;
|
||||
txn->inp_idx = 0;
|
||||
txn->txn_state = 0;
|
||||
@ -149,8 +163,10 @@ static char *decodeTerminator(char *code)
|
||||
return NULL;
|
||||
count = strlen(code);
|
||||
pResult = (char *) malloc(count + 1);
|
||||
if (!pResult)
|
||||
if (!pResult) {
|
||||
SICSLogWrite("Out of memory in AsyncProtocol::decodeTerminator", eError);
|
||||
return NULL;
|
||||
}
|
||||
memset(pResult, 0, count + 1);
|
||||
|
||||
pCh = pResult;
|
||||
@ -217,7 +233,7 @@ int AsyncProtocolAction(SConnection *pCon, SicsInterp *pSics,
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
if (strcasecmp(argv[1], "replyterminator") == 0) {
|
||||
else if (strcasecmp(argv[1], "replyterminator") == 0) {
|
||||
if (argc > 2) {
|
||||
char* pPtr = decodeTerminator(argv[2]);
|
||||
if (pPtr) {
|
||||
@ -238,13 +254,23 @@ int AsyncProtocolAction(SConnection *pCon, SicsInterp *pSics,
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
/* TODO: other actions */
|
||||
else if (strcasecmp(argv[1], "list") == 0) {
|
||||
int ac = 2;
|
||||
char* av[3] = { argv[0], 0, 0 };
|
||||
av[1] = "sendterminator";
|
||||
AsyncProtocolAction(pCon, pSics, pData, ac, av);
|
||||
av[1] = "replyterminator";
|
||||
AsyncProtocolAction(pCon, pSics, pData, ac, av);
|
||||
return 1;
|
||||
}
|
||||
/* handle any other actions here */
|
||||
return AsyncProtocolNoAction(pCon, pSics, pData, argc,argv);
|
||||
}
|
||||
|
||||
void defaultKillPrivate(pAsyncProtocol p) {
|
||||
if (p->privateData) {
|
||||
/* TODO: anything? */
|
||||
/* TODO: should we do anything? */
|
||||
free(p->privateData);
|
||||
}
|
||||
}
|
||||
|
||||
@ -252,7 +278,6 @@ void AsyncProtocolKill(void *pData) {
|
||||
pAsyncProtocol self = (pAsyncProtocol) pData;
|
||||
if(self->pDes)
|
||||
DeleteDescriptor(self->pDes);
|
||||
/* TODO: more destruction maybe */
|
||||
if(self->sendTerminator != NULL)
|
||||
free(self->sendTerminator);
|
||||
if(self->replyTerminator != NULL)
|
||||
@ -274,7 +299,7 @@ pAsyncProtocol AsyncProtocolCreate(SicsInterp *pSics, const char* protocolName,
|
||||
|
||||
self = (pAsyncProtocol) malloc(sizeof(AsyncProtocol));
|
||||
if (self == NULL) {
|
||||
/* TODO */
|
||||
SICSLogWrite("Out of memory in AsyncProtocolCreate", eError);
|
||||
return NULL;
|
||||
}
|
||||
memset(self, 0, sizeof(AsyncProtocol));
|
||||
@ -285,7 +310,7 @@ pAsyncProtocol AsyncProtocolCreate(SicsInterp *pSics, const char* protocolName,
|
||||
pKFunc = AsyncProtocolKill;
|
||||
iRet = AddCommand(pSics, protocolName, pFunc, pKFunc, self);
|
||||
if (!iRet ) {
|
||||
/* TODO */
|
||||
SICSLogWrite("AddCommand failed in AsyncProtocolCreate", eError);
|
||||
AsyncProtocolKill(self);
|
||||
return NULL;
|
||||
}
|
||||
@ -307,7 +332,7 @@ int AsyncProtocolFactory(SConnection *pCon, SicsInterp *pSics,
|
||||
}
|
||||
pAsyncProtocol pNew = AsyncProtocolCreate(pSics, argv[1],
|
||||
AsyncProtocolAction, AsyncProtocolKill);
|
||||
/* TODO: handle arguments */
|
||||
/* handle any extra arguments here */
|
||||
pNew->privateData = NULL;
|
||||
return 1;
|
||||
}
|
||||
|
||||
44
asyncqueue.c
44
asyncqueue.c
@ -181,7 +181,7 @@ static int StartCommand(pAsyncQueue self)
|
||||
char reply[1];
|
||||
int iRet;
|
||||
iRet = NETRead(sock, reply, 1, 0);
|
||||
if (iRet < 0) { /* TODO: EOF */
|
||||
if (iRet < 0) { /* EOF */
|
||||
iRet = AQ_Reconnect(self);
|
||||
if (iRet == 0)
|
||||
return 0;
|
||||
@ -306,7 +306,7 @@ static int MyCallback(void* context, int mode)
|
||||
char reply[1];
|
||||
|
||||
iRet = NETRead(self->pSock, reply, 1, 0);
|
||||
if (iRet < 0) { /* TODO: EOF */
|
||||
if (iRet < 0) { /* EOF */
|
||||
iRet = AQ_Reconnect(self);
|
||||
if (iRet <= 0)
|
||||
return iRet;
|
||||
@ -342,7 +342,10 @@ int AsyncUnitEnqueHead(pAsyncUnit unit, pAsyncTxn context)
|
||||
|
||||
assert(unit && unit->queue && unit->queue->protocol);
|
||||
myCmd = (pAQ_Cmd) malloc(sizeof(AQ_Cmd));
|
||||
/* TODO: check malloc */
|
||||
if (myCmd == NULL) {
|
||||
SICSLogWrite("ERROR: Out of memory in AsyncUnitEnqueHead", eError);
|
||||
return 0;
|
||||
}
|
||||
memset(myCmd, 0, sizeof(AQ_Cmd));
|
||||
myCmd->tran = context;
|
||||
myCmd->unit = unit;
|
||||
@ -358,7 +361,10 @@ int AsyncUnitEnqueueTxn(pAsyncUnit unit, pAsyncTxn pTxn)
|
||||
|
||||
assert(unit && unit->queue && unit->queue->protocol);
|
||||
myCmd = (pAQ_Cmd) malloc(sizeof(AQ_Cmd));
|
||||
/* TODO: check malloc */
|
||||
if (myCmd == NULL) {
|
||||
SICSLogWrite("ERROR: Out of memory in AsyncUnitEnqueueTxn", eError);
|
||||
return 0;
|
||||
}
|
||||
memset(myCmd, 0, sizeof(AQ_Cmd));
|
||||
myCmd->tran = pTxn;
|
||||
myCmd->unit = unit;
|
||||
@ -377,7 +383,10 @@ pAsyncTxn AsyncUnitPrepareTxn(pAsyncUnit unit,
|
||||
|
||||
assert(unit);
|
||||
myTxn = (pAsyncTxn) malloc(sizeof(AsyncTxn));
|
||||
assert(myTxn);
|
||||
if (myTxn == NULL) {
|
||||
SICSLogWrite("ERROR: Out of memory in AsyncUnitPrepareTxn", eError);
|
||||
return 0;
|
||||
}
|
||||
memset(myTxn, 0, sizeof(AsyncTxn));
|
||||
if (unit->queue->protocol->prepareTxn) {
|
||||
int iRet;
|
||||
@ -385,6 +394,11 @@ pAsyncTxn AsyncUnitPrepareTxn(pAsyncUnit unit,
|
||||
}
|
||||
else {
|
||||
myTxn->out_buf = (char*) malloc(cmd_len + 5);
|
||||
if (myTxn->out_buf == NULL) {
|
||||
SICSLogWrite("ERROR: Out of memory in AsyncUnitPrepareTxn", eError);
|
||||
free(myTxn);
|
||||
return 0;
|
||||
}
|
||||
memcpy(myTxn->out_buf, command, cmd_len);
|
||||
myTxn->out_len = cmd_len;
|
||||
if (myTxn->out_len < 2 ||
|
||||
@ -399,6 +413,12 @@ pAsyncTxn AsyncUnitPrepareTxn(pAsyncUnit unit,
|
||||
myTxn->inp_buf = NULL;
|
||||
else {
|
||||
myTxn->inp_buf = malloc(rsp_len + 1);
|
||||
if (myTxn->inp_buf == NULL) {
|
||||
SICSLogWrite("ERROR: Out of memory in AsyncUnitPrepareTxn", eError);
|
||||
free(myTxn->out_buf);
|
||||
free(myTxn);
|
||||
return 0;
|
||||
}
|
||||
memset(myTxn->inp_buf, 0, rsp_len + 1);
|
||||
}
|
||||
myTxn->inp_len = rsp_len;
|
||||
@ -477,7 +497,7 @@ int AsyncUnitWrite(pAsyncUnit unit, void* buffer, int buflen)
|
||||
sock = AsyncUnitGetSocket(unit);
|
||||
iRet = NETWrite(sock, buffer, buflen);
|
||||
/* TODO handle errors */
|
||||
if (iRet < 0) { /* TODO: EOF */
|
||||
if (iRet < 0) { /* EOF */
|
||||
iRet = AQ_Reconnect(unit->queue);
|
||||
if (iRet == 0)
|
||||
return 0;
|
||||
@ -708,7 +728,7 @@ static pAsyncQueue AQ_Create(const char* host, const char* port)
|
||||
}
|
||||
if (self == NULL) {
|
||||
channel = NETConnectWithFlags(host, port_no, 0);
|
||||
/* TODO */
|
||||
/* TODO handle asynchronous connection */
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -738,7 +758,7 @@ static pAsyncQueue AQ_Create(const char* host, const char* port)
|
||||
|
||||
static int AQ_Init(pAsyncQueue self)
|
||||
{
|
||||
/* TODO: Init the controller */
|
||||
/* Init the controller */
|
||||
if (self->nw_ctx == NULL)
|
||||
NetWatchRegisterCallback(&self->nw_ctx,
|
||||
self->pSock->sockid,
|
||||
@ -830,7 +850,7 @@ int AsyncQueueFactory(SConnection *pCon, SicsInterp *pSics,
|
||||
SCWrite(pCon, line, eError);
|
||||
}
|
||||
}
|
||||
/* TODO: asynchronous connection */
|
||||
/* TODO: implement asynchronous connection */
|
||||
channel = NETConnectWithFlags(argv[3], port_no, 0);
|
||||
}
|
||||
|
||||
@ -895,7 +915,11 @@ int AsyncUnitCreateHost(const char* host, const char* port, pAsyncUnit* handle)
|
||||
status = AQ_Init(self);
|
||||
|
||||
unit = (pAsyncUnit) malloc(sizeof(AsyncUnit));
|
||||
/* TODO: check malloc failure */
|
||||
if (unit == NULL) {
|
||||
SICSLogWrite("ERROR: Out of memory in AsyncUnitCreateHost", eError);
|
||||
*handle = NULL;
|
||||
return 0;
|
||||
}
|
||||
memset(unit, 0, sizeof(AsyncUnit));
|
||||
++self->unit_count;
|
||||
unit->queue = self;
|
||||
|
||||
Reference in New Issue
Block a user