int lsRecvMsg_(int sock, char *buf, int bufLen, struct LSFHeader *hdr, char *data, bool_t (*xdrFunc)(), int (*readFunc)()) { XDR xdrs; int cc; xdrmem_create(&xdrs, buf, bufLen, XDR_DECODE); if ((cc = readDecodeHdr_(sock, buf, readFunc, &xdrs, hdr)) < 0) { xdr_destroy(&xdrs); return (cc); } if (hdr->length == 0 || data == NULL) { xdr_destroy(&xdrs); return (0); } XDR_SETPOS(&xdrs, 0); if ((cc = readDecodeMsg_(sock, buf, hdr, readFunc, &xdrs, data, xdrFunc, NULL)) < 0) { xdr_destroy(&xdrs); return (cc); } return (0); }
int expectReturnCode_(int s, int seqno, struct LSFHeader *repHdr) { struct LSFHeader buf; static char fname[] = "expectReturnCode_"; XDR xdrs; int rc; xdrmem_create(&xdrs, (char *) &buf, sizeof(struct LSFHeader), XDR_DECODE); for (;;) { if (logclass & LC_TRACE) ls_syslog(LOG_DEBUG, "%s: calling readDecodeHdr_...", fname); xdr_setpos(&xdrs, 0); if (readDecodeHdr_(s, (char *) &buf, b_read_fix, &xdrs, repHdr) < 0) { xdr_destroy(&xdrs); return -1; } if (repHdr->opCode == RES_NONRES) { rc = enqueueTaskMsg_(s, repHdr->refCode, repHdr); if (rc < 0) { xdr_destroy(&xdrs); return rc; } } else { if (repHdr->refCode == seqno) break; rc = ackAsyncReturnCode_(s, repHdr); if (rc < 0) { xdr_destroy(&xdrs); return rc; } } } xdr_destroy(&xdrs); return 0; }
void rfServ_(int acceptSock) { static char fname[] = "rfServ_()"; struct LSFHeader msgHdr; struct LSFHeader buf; struct sockaddr_in from; socklen_t fromLen = sizeof(from); int sock; XDR xdrs; sock = accept(acceptSock, (struct sockaddr *)&from, &fromLen); if (sock < 0) { ls_errlog(stderr, I18N_FUNC_FAIL_MM, fname, "readDecodeHdr_"); closesocket(acceptSock); return; } xdrmem_create(&xdrs, (char *) &buf, sizeof(buf), XDR_DECODE); for (;;) { XDR_SETPOS(&xdrs, 0); if (readDecodeHdr_(sock, (char *)&buf, SOCK_READ_FIX, &xdrs, &msgHdr) < 0) { ls_errlog(stderr, I18N_FUNC_FAIL_MM, fname, "readDecodeHdr_"); closesocket(sock); xdr_destroy(&xdrs); return; } switch (msgHdr.opCode) { case RF_OPEN: ropen(sock, &msgHdr); break; case RF_CLOSE: rclose(sock, &msgHdr); break; case RF_WRITE: rwrite(sock, &msgHdr); break; case RF_READ: rread(sock, &msgHdr); break; case RF_STAT: rstat(sock, &msgHdr); break; case RF_GETMNTHOST: rgetmnthost(sock, &msgHdr); break; case RF_FSTAT: rfstat(sock, &msgHdr); break; case RF_LSEEK: rlseek(sock, &msgHdr); break; case RF_UNLINK: runlink(sock, &msgHdr); break; case RF_TERMINATE: closesocket(sock); return; default: ls_errlog(stderr, _i18n_msg_get(ls_catd, NL_SETN, 602, "%s: Unknown opcode %d"), fname, msgHdr.opCode); xdr_destroy(&xdrs); break; } } }
int lsMsgWait_(int inTidCnt, int *tidArray, int *rdyTidCnt, int inFdCnt, int *fdArray, int *rdyFdCnt, int *outFdArray, struct timeval *timeout, int options) { int i; fd_set rm; struct tid *taskEnt; int maxfd; int nready; char hdrBuf[sizeof(struct LSFHeader)]; struct LSFHeader msgHdr; int rc; int rdycnt; XDR xdrs; bool_t tMsgQNonEmpty; int nBitsSet; bool_t anythingRdy; if ((! rdyTidCnt && ! rdyFdCnt) || (! tidArray && !fdArray) || (! inTidCnt && ! inFdCnt)) return 0; for (i = 0; i < inFdCnt; i++) outFdArray[i] = -1; Again: tMsgQNonEmpty = FALSE; FD_ZERO(&rm); nBitsSet = 0; if (rdyTidCnt) *rdyTidCnt = 0; if (rdyFdCnt) *rdyFdCnt = 0; if (inFdCnt > 0 && fdArray) for (i = 0; i < inFdCnt; i++) { if (FD_NOT_VALID(fdArray[i])) { lserrno = LSE_BAD_ARGS; rc = -1; goto Fail; } FD_SET(fdArray[i], &rm); nBitsSet++; } rdycnt = 0; if (inTidCnt && tidArray) { for (i = 0; i < inTidCnt; i++) { rc = lsMsgRdy_(tidArray[i], NULL); if (rc > 0) { tMsgQNonEmpty = TRUE; rdycnt++; continue; } taskEnt = tid_find(tidArray[i]); if (taskEnt == NULL) { rc = -1; goto Fail; } if (FD_NOT_VALID(taskEnt->sock)) { lserrno = LSE_BAD_ARGS; rc = -1; goto Fail; } nBitsSet++; FD_SET(taskEnt->sock, &rm); } if (tMsgQNonEmpty) { *rdyTidCnt = rdycnt; return 0; } } if (nBitsSet == 0) return 0; maxfd = sysconf(_SC_OPEN_MAX); if (maxfd > 1024) maxfd = 1024-1; nready = select(maxfd, &rm, NULL, NULL, timeout); if (nready < 0) { if (errno == EINTR) { goto Again; } else { lserrno = LSE_SELECT_SYS; rc = -1; goto Fail; } } if (rdyFdCnt) { rdycnt = 0; for (i = 0; i < inFdCnt; i++) { if (FD_ISSET(fdArray[i], &rm)) { rdycnt++; outFdArray[i] = fdArray[i]; } else outFdArray[i] = -1; } *rdyFdCnt = rdycnt; } if (nready == 0) { if (rdyTidCnt) *rdyTidCnt = 0; return 0; } if (rdyTidCnt) { rdycnt = 0; xdrmem_create(&xdrs, hdrBuf, sizeof(struct LSFHeader), XDR_DECODE); for (i = 0; i < inTidCnt; i++) { taskEnt = tidFindIgnoreConn_(tidArray[i]); if (taskEnt == NULL) { rc = -1; xdr_destroy(&xdrs); goto Fail; } if (FD_NOT_VALID(taskEnt->sock)) continue; if (! FD_ISSET(taskEnt->sock, &rm)) continue; xdr_setpos(&xdrs, 0); rc = readDecodeHdr_(taskEnt->sock, hdrBuf, b_read_fix, &xdrs, &msgHdr); if (rc < 0) { int nTids; int *tidSameConns; int tidIDx; rc = tidSameConnection_(taskEnt->sock, &nTids, &tidSameConns); for (tidIDx = 0; tidIDx < nTids; tidIDx++) { rc = enqueueTaskMsg_(-1, tidSameConns[tidIDx], NULL); if (rc < 0) { free(tidSameConns); xdr_destroy(&xdrs); goto Fail; } } rdycnt += nTids; free(tidSameConns); _lostconnection_(taskEnt->host); } else if (msgHdr.opCode != RES_NONRES) { rc = ackAsyncReturnCode_(taskEnt->sock, &msgHdr); if (rc < 0) { xdr_destroy(&xdrs); goto Fail; } } else { rc = enqueueTaskMsg_(taskEnt->sock, msgHdr.refCode, &msgHdr); if (rc < 0) { xdr_destroy(&xdrs); goto Fail; } FD_CLR(taskEnt->sock, &rm); rdycnt++; } } xdr_destroy(&xdrs); *rdyTidCnt = rdycnt; } anythingRdy = FALSE; if (rdyTidCnt) if (*rdyTidCnt > 0) anythingRdy = TRUE; if (rdyFdCnt) if (*rdyFdCnt > 0) anythingRdy = TRUE; if (! anythingRdy) goto Again; rc = 0; Fail: return rc; }