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;
}
