version 1.9.2.12, 2012/05/16 09:02:48
|
version 1.9.2.20, 2012/05/17 11:01:30
|
Line 52 closeClient(sched_task_t *task)
|
Line 52 closeClient(sched_task_t *task)
|
rpc_cli_t *c = TASK_ARG(task); |
rpc_cli_t *c = TASK_ARG(task); |
rpc_srv_t *s = c->cli_parent; |
rpc_srv_t *s = c->cli_parent; |
|
|
schedCancelby(s->srv_root, taskMAX, CRITERIA_ARG, TASK_ARG(task), NULL); | schedCancelby(TASK_ROOT(task), taskMAX, CRITERIA_ARG, TASK_ARG(task), NULL); |
|
|
/* close client socket */ |
/* close client socket */ |
if (TASK_VAL(task)) |
if (TASK_VAL(task)) |
Line 82 txPacket(sched_task_t *task)
|
Line 82 txPacket(sched_task_t *task)
|
if (rpc->call_argc) { |
if (rpc->call_argc) { |
f = rpc_srv_getCall(s, ntohs(rpc->call_tag)); |
f = rpc_srv_getCall(s, ntohs(rpc->call_tag)); |
if (!f) { |
if (!f) { |
|
rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server"); |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_rep.ret = RPC_ERROR(-1); |
rpc->call_rep.ret = RPC_ERROR(-1); |
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); |
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); |
Line 186 rxPacket(sched_task_t *task)
|
Line 187 rxPacket(sched_task_t *task)
|
rlen = recv(TASK_FD(task), buf, AIT_LEN(&c->cli_buf), 0); |
rlen = recv(TASK_FD(task), buf, AIT_LEN(&c->cli_buf), 0); |
if (rlen < 1) { |
if (rlen < 1) { |
/* close connection */ |
/* close connection */ |
schedEvent(TASK_ROOT(task), closeClient, c, 0, NULL, 0); | schedEvent(TASK_ROOT(task), closeClient, c, 42, NULL, 0); |
return NULL; |
return NULL; |
} |
} |
|
|
do { |
do { |
/* check RPC packet */ |
/* check RPC packet */ |
if (rlen < sizeof(struct tagRPCCall)) { |
if (rlen < sizeof(struct tagRPCCall)) { |
rpc_SetErr(ERPCMISMATCH, "Too short RPC packet"); | rpc_SetErr(ERPCMISMATCH, "Short RPC packet"); |
|
|
schedReadSelf(task); |
schedReadSelf(task); |
return NULL; |
return NULL; |
Line 257 acceptClients(sched_task_t *task)
|
Line 258 acceptClients(sched_task_t *task)
|
c = malloc(sizeof(rpc_cli_t)); |
c = malloc(sizeof(rpc_cli_t)); |
if (!c) { |
if (!c) { |
LOGERR; |
LOGERR; |
srv->srv_kill = kill; | srv->srv_kill = 1; |
return NULL; |
return NULL; |
} else { |
} else { |
memset(c, 0, sizeof(rpc_cli_t)); |
memset(c, 0, sizeof(rpc_cli_t)); |
Line 270 acceptClients(sched_task_t *task)
|
Line 271 acceptClients(sched_task_t *task)
|
AIT_SET_BUF2(&c->cli_buf, 0, srv->srv_netbuf); |
AIT_SET_BUF2(&c->cli_buf, 0, srv->srv_netbuf); |
|
|
/* accept client */ |
/* accept client */ |
c->cli_sock = accept(srv->srv_server.cli_sock, &c->cli_sa.sa, &salen); | c->cli_sock = accept(TASK_FD(task), &c->cli_sa.sa, &salen); |
if (c->cli_sock == -1) { |
if (c->cli_sock == -1) { |
LOGERR; |
LOGERR; |
AIT_FREE_VAL(&c->cli_buf); |
AIT_FREE_VAL(&c->cli_buf); |
Line 288 end:
|
Line 289 end:
|
/* ------------------------------------------------------ */ |
/* ------------------------------------------------------ */ |
|
|
static void * |
static void * |
acceptBLOBClients(sched_task_t *task) | closeBLOBClient(sched_task_t *task) |
{ |
{ |
rpc_srv_t *srv = TASK_ARG(task); | rpc_cli_t *c = TASK_ARG(task); |
rpc_cli_t *c = NULL; | rpc_srv_t *s = c->cli_parent; |
register int i; | |
socklen_t salen = sizeof(io_sockaddr_t); | |
|
|
/* check free slots for connect */ | schedCancelby(TASK_ROOT(task), taskMAX, CRITERIA_ARG, TASK_ARG(task), NULL); |
for (i = 0; i < io_arraySize(srv->srv_clients) && | |
(c = io_array(srv->srv_clients, i, rpc_cli_t*)); i++); | |
if (c) /* no more free slots! */ | |
goto end; | |
c = malloc(sizeof(rpc_cli_t)); | |
if (!c) { | |
LOGERR; | |
srv->srv_kill = kill; | |
return NULL; | |
} else { | |
memset(c, 0, sizeof(rpc_cli_t)); | |
io_arraySet(srv->srv_clients, i, c); | |
c->cli_id = i; | |
c->cli_parent = srv; | |
} | |
|
|
/* alloc empty buffer */ | /* close client socket */ |
AIT_SET_BUF2(&c->cli_buf, 0, srv->srv_netbuf); | if (TASK_VAL(task)) |
| shutdown(c->cli_sock, SHUT_RDWR); |
| close(c->cli_sock); |
|
|
/* accept client */ | /* free buffer */ |
c->cli_sock = accept(srv->srv_server.cli_sock, &c->cli_sa.sa, &salen); | AIT_FREE_VAL(&c->cli_buf); |
if (c->cli_sock == -1) { | |
LOGERR; | |
AIT_FREE_VAL(&c->cli_buf); | |
io_arrayDel(srv->srv_clients, i, 42); | |
goto end; | |
} else | |
fcntl(c->cli_sock, F_SETFL, fcntl(c->cli_sock, F_GETFL) | O_NONBLOCK); | |
|
|
schedRead(TASK_ROOT(task), rxPacket, c, c->cli_sock, NULL, 0); | io_arrayDel(s->srv_blob.clients, c->cli_id, 42); |
end: | |
schedReadSelf(task); | |
return NULL; |
return NULL; |
} |
} |
|
|
#if 0 |
|
static void * |
static void * |
txBLOB(sched_task_t *task) |
txBLOB(sched_task_t *task) |
{ |
{ |
u_char *buf = TASK_DATA(task); | rpc_cli_t *c = TASK_ARG(task); |
| u_char *buf = AIT_GET_BUF(&c->cli_buf); |
struct tagBLOBHdr *blob = (struct tagBLOBHdr *) buf; |
struct tagBLOBHdr *blob = (struct tagBLOBHdr *) buf; |
int wlen = sizeof(struct tagBLOBHdr); |
int wlen = sizeof(struct tagBLOBHdr); |
|
|
Line 344 txBLOB(sched_task_t *task)
|
Line 321 txBLOB(sched_task_t *task)
|
blob->hdr_crc = htons(crcFletcher16((u_short*) buf, wlen / 2)); |
blob->hdr_crc = htons(crcFletcher16((u_short*) buf, wlen / 2)); |
|
|
/* send reply */ |
/* send reply */ |
wlen = send(TASK_FD(task), buf, wlen, 0); | wlen = send(TASK_FD(task), buf, wlen, MSG_NOSIGNAL); |
if (wlen == -1) | if (wlen == -1 || wlen != sizeof(struct tagBLOBHdr)) { |
LOGERR; | /* close blob connection */ |
else if (wlen != sizeof(struct tagBLOBHdr)) | schedEvent(TASK_ROOT(task), closeBLOBClient, c, 42, NULL, 0); |
rpc_SetErr(EPROCUNAVAIL, "RPC reply, should be send %d bytes, " | } |
"really sended %d bytes", sizeof(struct tagBLOBHdr), wlen); | |
|
|
return NULL; |
return NULL; |
} |
} |
Line 360 rxBLOB(sched_task_t *task)
|
Line 336 rxBLOB(sched_task_t *task)
|
rpc_cli_t *c = TASK_ARG(task); |
rpc_cli_t *c = TASK_ARG(task); |
rpc_srv_t *s = c->cli_parent; |
rpc_srv_t *s = c->cli_parent; |
rpc_blob_t *b; |
rpc_blob_t *b; |
u_char *buf = TASK_DATA(task); | u_char *buf = AIT_GET_BUF(&c->cli_buf); |
struct tagBLOBHdr *blob = (struct tagBLOBHdr *) buf; |
struct tagBLOBHdr *blob = (struct tagBLOBHdr *) buf; |
int rlen; |
int rlen; |
u_short crc; |
u_short crc; |
struct timespec ts; |
|
|
|
/* check for disable service at this moment? */ | memset(buf, 0, AIT_LEN(&c->cli_buf)); |
if (!s || s->srv_blob.state == disable) { | rlen = recv(TASK_FD(task), buf, AIT_LEN(&c->cli_buf), 0); |
usleep(100000); | if (rlen < 1) { |
#ifdef HAVE_PTHREAD_YIELD | /* close blob connection */ |
pthread_yield(); | schedEvent(TASK_ROOT(task), closeBLOBClient, c, 42, NULL, 0); |
#endif | |
schedRead(TASK_ROOT(task), rxBLOB, TASK_ARG(task), TASK_FD(task), | |
TASK_DATA(task), TASK_DATLEN(task)); | |
return NULL; |
return NULL; |
} |
} |
|
|
memset(buf, 0, TASK_DATLEN(task)); | /* check BLOB packet */ |
rlen = recv(TASK_FD(task), buf, TASK_DATLEN(task), 0); | |
if (rlen == -1) { | |
LOGERR; | |
c->cli_kill = kill; | |
return NULL; | |
} else if (!rlen) { /* receive EOF */ | |
c->cli_kill = kill; | |
return NULL; | |
} | |
| |
if (rlen < sizeof(struct tagBLOBHdr)) { |
if (rlen < sizeof(struct tagBLOBHdr)) { |
rpc_SetErr(ERPCMISMATCH, "Too short BLOB packet"); | rpc_SetErr(ERPCMISMATCH, "Short BLOB packet"); |
schedRead(TASK_ROOT(task), rxBLOB, TASK_ARG(task), TASK_FD(task), | |
TASK_DATA(task), TASK_DATLEN(task)); | schedReadSelf(task); |
return NULL; |
return NULL; |
} |
} |
|
|
Line 400 rxBLOB(sched_task_t *task)
|
Line 362 rxBLOB(sched_task_t *task)
|
blob->hdr_crc ^= blob->hdr_crc; |
blob->hdr_crc ^= blob->hdr_crc; |
if (crc != crcFletcher16((u_short*) buf, rlen / 2)) { |
if (crc != crcFletcher16((u_short*) buf, rlen / 2)) { |
rpc_SetErr(ERPCMISMATCH, "Bad CRC BLOB packet"); |
rpc_SetErr(ERPCMISMATCH, "Bad CRC BLOB packet"); |
schedRead(TASK_ROOT(task), rxBLOB, TASK_ARG(task), TASK_FD(task), | |
TASK_DATA(task), TASK_DATLEN(task)); | schedReadSelf(task); |
return NULL; |
return NULL; |
} |
} |
|
|
Line 410 rxBLOB(sched_task_t *task)
|
Line 372 rxBLOB(sched_task_t *task)
|
rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session"); |
rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session"); |
blob->hdr_cmd = error; |
blob->hdr_cmd = error; |
goto end; |
goto end; |
} else { |
|
/* change socket timeout from last packet */ |
|
ts.tv_sec = blob->hdr_session.sess_timeout; |
|
ts.tv_nsec = 0; |
|
schedPolling(TASK_ROOT(task), &ts, NULL); |
|
} |
} |
|
|
/* Go to proceed packet ... */ |
/* Go to proceed packet ... */ |
Line 463 rxBLOB(sched_task_t *task)
|
Line 420 rxBLOB(sched_task_t *task)
|
} |
} |
|
|
end: |
end: |
schedWrite(TASK_ROOT(task), txBLOB, TASK_ARG(task), TASK_FD(task), | schedWrite(TASK_ROOT(task), txBLOB, TASK_ARG(task), TASK_FD(task), NULL, 0); |
TASK_DATA(task), TASK_DATLEN(task)); | schedReadSelf(task); |
schedRead(TASK_ROOT(task), rxBLOB, TASK_ARG(task), TASK_FD(task), | |
TASK_DATA(task), TASK_DATLEN(task)); | |
return NULL; |
return NULL; |
} |
} |
|
|
static void * |
static void * |
rpc_srv_dispatchVars(void *arg) | acceptBLOBClients(sched_task_t *task) |
{ |
{ |
rpc_cli_t *c = arg; | rpc_srv_t *srv = TASK_ARG(task); |
rpc_srv_t *s; | rpc_cli_t *c = NULL; |
sched_root_task_t *root; | register int i; |
u_char *buf; | socklen_t salen = sizeof(io_sockaddr_t); |
struct timespec ts = { DEF_RPC_TIMEOUT, 0 }; | |
|
|
if (!arg) { | /* check free slots for connect */ |
rpc_SetErr(EINVAL, "Invalid parameter can`t procced BLOB"); | for (i = 0; i < io_arraySize(srv->srv_blob.clients) && |
return NULL; | (c = io_array(srv->srv_blob.clients, i, rpc_cli_t*)); i++); |
} else | if (c) /* no more free slots! */ |
s = c->cli_parent; | goto end; |
| c = malloc(sizeof(rpc_cli_t)); |
/* allocate net buffer */ | if (!c) { |
buf = malloc(sizeof(struct tagBLOBHdr)); | |
if (!buf) { | |
LOGERR; |
LOGERR; |
|
srv->srv_kill = srv->srv_blob.kill = 1; |
return NULL; |
return NULL; |
} |
|
|
|
root = schedBegin(); |
|
if (!root) { |
|
rpc_SetErr(sched_GetErrno(), "%s", sched_GetError()); |
|
free(buf); |
|
return NULL; |
|
} else { |
} else { |
schedTermCondition(root, kill); | memset(c, 0, sizeof(rpc_cli_t)); |
schedPolling(root, &ts, NULL); | io_arraySet(srv->srv_blob.clients, i, c); |
| c->cli_id = i; |
| c->cli_parent = srv; |
} |
} |
|
|
schedRead(root, rxBLOB, c, c->cli_sock, buf, sizeof(struct tagBLOBHdr)); | /* alloc empty buffer */ |
| AIT_SET_BUF2(&c->cli_buf, 0, srv->srv_netbuf); |
|
|
schedRun(root, (void*) &c->cli_kill); | /* accept client */ |
schedEnd(&root); | c->cli_sock = accept(TASK_FD(task), &c->cli_sa.sa, &salen); |
| if (c->cli_sock == -1) { |
| LOGERR; |
| AIT_FREE_VAL(&c->cli_buf); |
| io_arrayDel(srv->srv_blob.clients, i, 42); |
| goto end; |
| } else |
| fcntl(c->cli_sock, F_SETFL, fcntl(c->cli_sock, F_GETFL) | O_NONBLOCK); |
|
|
shutdown(c->cli_sock, SHUT_RDWR); | schedRead(TASK_ROOT(task), rxBLOB, c, c->cli_sock, NULL, 0); |
close(c->cli_sock); | end: |
memset(c, 0, sizeof(rpc_cli_t)); | schedReadSelf(task); |
free(buf); | |
return NULL; |
return NULL; |
} |
} |
#endif |
|
|
|
/* ------------------------------------------------------ */ |
/* ------------------------------------------------------ */ |
|
|
Line 529 int
|
Line 483 int
|
rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_short Port, const char *diskDir) |
rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_short Port, const char *diskDir) |
{ |
{ |
int n = 1; |
int n = 1; |
io_sockaddr_t sa; |
|
|
|
if (!srv || srv->srv_kill) { |
if (!srv || srv->srv_kill) { |
rpc_SetErr(EINVAL, "Invalid parameters can`t init BLOB server"); |
rpc_SetErr(EINVAL, "Invalid parameters can`t init BLOB server"); |
Line 549 rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
|
Line 502 rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
|
srv->srv_blob.server.cli_parent = srv; |
srv->srv_blob.server.cli_parent = srv; |
|
|
memcpy(&srv->srv_blob.server.cli_sa, &srv->srv_server.cli_sa, sizeof(io_sockaddr_t)); |
memcpy(&srv->srv_blob.server.cli_sa, &srv->srv_server.cli_sa, sizeof(io_sockaddr_t)); |
switch (sa.sa.sa_family) { | switch (srv->srv_blob.server.cli_sa.sa.sa_family) { |
case AF_INET: |
case AF_INET: |
sa.sin.sin_port = htons(Port ? Port : ntohs(sa.sin.sin_port) + 1); | srv->srv_blob.server.cli_sa.sin.sin_port = |
| htons(Port ? Port : ntohs(srv->srv_blob.server.cli_sa.sin.sin_port) + 1); |
break; |
break; |
case AF_INET6: |
case AF_INET6: |
sa.sin6.sin6_port = htons(Port ? Port : ntohs(sa.sin6.sin6_port) + 1); | srv->srv_blob.server.cli_sa.sin6.sin6_port = |
| htons(Port ? Port : ntohs(srv->srv_blob.server.cli_sa.sin6.sin6_port) + 1); |
break; |
break; |
case AF_LOCAL: |
case AF_LOCAL: |
strlcat(sa.sun.sun_path, ".blob", sizeof sa.sun.sun_path); | strlcat(srv->srv_blob.server.cli_sa.sun.sun_path, ".blob", |
| sizeof srv->srv_blob.server.cli_sa.sun.sun_path); |
break; |
break; |
default: |
default: |
AIT_FREE_VAL(&srv->srv_blob.dir); |
AIT_FREE_VAL(&srv->srv_blob.dir); |
Line 636 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
|
Line 592 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
|
if (!srv) |
if (!srv) |
return; |
return; |
|
|
|
pthread_cancel(srv->srv_blob.tid); |
|
pthread_join(srv->srv_blob.tid, NULL); |
|
|
/* close all clients connections & server socket */ |
/* close all clients connections & server socket */ |
for (i = 0; i < io_arraySize(srv->srv_blob.clients); i++) { |
for (i = 0; i < io_arraySize(srv->srv_blob.clients); i++) { |
c = io_array(srv->srv_blob.clients, i, rpc_cli_t*); |
c = io_array(srv->srv_blob.clients, i, rpc_cli_t*); |
Line 643 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
|
Line 602 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
|
shutdown(c->cli_sock, SHUT_RDWR); |
shutdown(c->cli_sock, SHUT_RDWR); |
close(c->cli_sock); |
close(c->cli_sock); |
|
|
io_arrayDel(srv->srv_blob.clients, i, 42); | schedCancelby(srv->srv_blob.root, taskMAX, CRITERIA_ARG, c, NULL); |
| AIT_FREE_VAL(&c->cli_buf); |
} |
} |
|
io_arrayDel(srv->srv_blob.clients, i, 42); |
} |
} |
io_arrayDestroy(&srv->srv_blob.clients); |
io_arrayDestroy(&srv->srv_blob.clients); |
|
|
Line 660 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
|
Line 621 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
|
|
|
schedEnd(&srv->srv_blob.root); |
schedEnd(&srv->srv_blob.root); |
AIT_FREE_VAL(&srv->srv_blob.dir); |
AIT_FREE_VAL(&srv->srv_blob.dir); |
|
|
srv->srv_blob.kill = 1; |
|
} |
} |
|
|
/* |
/* |
Line 692 rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv)
|
Line 651 rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv)
|
return -1; |
return -1; |
} |
} |
|
|
#if 0 |
|
for (c = srv->srv_blob.clients, i = 0; i < srv->srv_numcli && c; i++, c++) |
|
if (!c->cli_sa.sa.sa_family) |
|
break; |
|
if (i >= srv->srv_numcli) { |
|
#ifdef HAVE_PTHREAD_YIELD |
|
pthread_yield(); |
|
#endif |
|
usleep(1000000); |
|
continue; |
|
} |
|
|
|
c->cli_sock = accept(srv->srv_blob.server.cli_sock, &c->cli_sa.sa, &salen); |
|
if (c->cli_sock == -1) { |
|
LOGERR; |
|
continue; |
|
} else |
|
c->cli_parent = srv; |
|
} |
|
#endif |
|
|
|
/* main rpc loop */ |
/* main rpc loop */ |
schedRun(srv->srv_blob.root, &srv->srv_blob.kill); |
schedRun(srv->srv_blob.root, &srv->srv_blob.kill); |
return 0; |
return 0; |
Line 751 rpc_srv_initServer(u_int regProgID, u_char regProcID,
|
Line 689 rpc_srv_initServer(u_int regProgID, u_char regProcID,
|
else |
else |
netBuf = io_align(netBuf, 1); /* align netBuf length */ |
netBuf = io_align(netBuf, 1); /* align netBuf length */ |
|
|
|
#ifdef HAVE_SRANDOMDEV |
|
srandomdev(); |
|
#else |
|
time_t tim; |
|
|
|
srandom((time(&tim) ^ getpid())); |
|
#endif |
|
|
srv = malloc(sizeof(rpc_srv_t)); |
srv = malloc(sizeof(rpc_srv_t)); |
if (!srv) { |
if (!srv) { |
LOGERR; |
LOGERR; |
Line 814 rpc_srv_initServer(u_int regProgID, u_char regProcID,
|
Line 760 rpc_srv_initServer(u_int regProgID, u_char regProcID,
|
goto err; |
goto err; |
} |
} |
|
|
|
rpc_register_srvPing(srv); |
|
|
return srv; |
return srv; |
err: /* error condition */ |
err: /* error condition */ |
close(srv->srv_server.cli_sock); |
close(srv->srv_server.cli_sock); |
Line 836 rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
|
Line 784 rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
|
register int i; |
register int i; |
rpc_func_t *f, *tmp; |
rpc_func_t *f, *tmp; |
|
|
if (!psrv || !*psrv) { | if (!psrv || !*psrv) |
rpc_SetErr(EINVAL, "Can`t destroy server because parameter is null!"); | |
return; |
return; |
} |
|
|
|
if (!(*psrv)->srv_blob.kill) |
if (!(*psrv)->srv_blob.kill) |
rpc_srv_endBLOBServer(*psrv); |
rpc_srv_endBLOBServer(*psrv); |
Line 851 rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
|
Line 797 rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
|
shutdown(c->cli_sock, SHUT_RDWR); |
shutdown(c->cli_sock, SHUT_RDWR); |
close(c->cli_sock); |
close(c->cli_sock); |
|
|
io_arrayDel((*psrv)->srv_clients, i, 42); | schedCancelby((*psrv)->srv_root, taskMAX, CRITERIA_ARG, c, NULL); |
| AIT_FREE_VAL(&c->cli_buf); |
} |
} |
|
io_arrayDel((*psrv)->srv_clients, i, 42); |
} |
} |
io_arrayDestroy(&(*psrv)->srv_clients); |
io_arrayDestroy(&(*psrv)->srv_clients); |
|
|
Line 925 rpc_srv_execCall(rpc_func_t * __restrict call, struct
|
Line 873 rpc_srv_execCall(rpc_func_t * __restrict call, struct
|
} |
} |
|
|
func = AIT_GET_LIKE(&call->func_name, rpc_callback_t); |
func = AIT_GET_LIKE(&call->func_name, rpc_callback_t); |
return func(call, ntohs(rpc->call_argc), args); | return func(call, rpc, args); |
} |
} |