Annotation of fam/libfam/Client.c++, Revision 1.1
1.1 ! trev 1: // Copyright (C) 1999 Silicon Graphics, Inc. All Rights Reserved.
! 2: //
! 3: // This program is free software; you can redistribute it and/or modify it
! 4: // under the terms of version 2.1 of the GNU Lesser General Public License
! 5: // as published by the Free Software Foundation.
! 6: //
! 7: // This program is distributed in the hope that it would be useful, but
! 8: // WITHOUT ANY WARRANTY; without even the implied warranty of
! 9: // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. Further, any
! 10: // license provided herein, whether implied or otherwise, is limited to
! 11: // this program in accordance with the express provisions of the GNU Lesser
! 12: // General Public License. Patent licenses, if any, provided herein do not
! 13: // apply to combinations of this program with other product or programs, or
! 14: // any other product whatsoever. This program is distributed without any
! 15: // warranty that the program is delivered free of the rightful claim of any
! 16: // third person by way of infringement or the like. See the GNU Lesser
! 17: // General Public License for more details.
! 18: //
! 19: // You should have received a copy of the GNU General Public License along
! 20: // with this program; if not, write the Free Software Foundation, Inc., 59
! 21: // Temple Place - Suite 330, Boston MA 02111-1307, USA.
! 22:
! 23: #include <stdio.h>
! 24: #include <stdlib.h>
! 25: #include <unistd.h>
! 26: #include <netinet/in.h>
! 27: #include <sys/un.h>
! 28: #include <sys/socket.h>
! 29: #include <rpc/rpc.h>
! 30: #include <rpc/pmap_clnt.h>
! 31: #include <rpc/pmap_prot.h>
! 32: #include <string.h> // for memset
! 33: #include <ctype.h>
! 34: #include <syslog.h>
! 35: #include <errno.h>
! 36:
! 37: #include <iostream.h>
! 38:
! 39: #include "fam.h"
! 40: #include "Client.h"
! 41:
! 42: static void getword(const char *p, u_int32_t *l);
! 43:
! 44: Client::Client(long host, unsigned int prog, int vers)
! 45: : sock(0), haveCompleteEvent(false), userData(NULL), endExist(NULL),
! 46: inend(inbuf)
! 47: {
! 48: struct sockaddr_in sin;
! 49:
! 50: memset(&sin, 0, sizeof sin);
! 51: sin.sin_family = AF_INET;
! 52: sin.sin_addr.s_addr = htonl(host);
! 53: // This is set below instead.
! 54: //sin.sin_port = htons(pmap_getport(&sin, prog, vers, IPPROTO_TCP));
! 55:
! 56: //
! 57: // We'll run through the list of pmaps ourselves instead of calling
! 58: // pmap_getport, because pmap_getport will give you the port for a
! 59: // version 1 service even when you ask for version 2, and we really
! 60: // need to know which version of fam we're talking to. (Isn't there
! 61: // an easier way to do that?)
! 62: //
! 63: pmaplist *pl = pmap_getmaps(&sin); // this is leaked; see note below loop
! 64: unsigned long bestvers = 0;
! 65: for (pmaplist *plp = pl; plp != NULL; plp = plp->pml_next)
! 66: {
! 67: if ((plp->pml_map.pm_prog == prog) &&
! 68: (plp->pml_map.pm_prot == IPPROTO_TCP))
! 69: {
! 70: if (plp->pml_map.pm_vers > bestvers)
! 71: {
! 72: bestvers = plp->pml_map.pm_vers;
! 73: sin.sin_port = htons((unsigned short)(plp->pml_map.pm_port));
! 74: if (bestvers == vers)
! 75: {
! 76: break;
! 77: }
! 78: }
! 79: }
! 80: }
! 81: // We can't call clnt_freeres because we don't have the client, and
! 82: // Purify says this xdr_free gives a bunch of UMR & UMW's, so we'll
! 83: // just leak it. This sucks! (call CLNT_CALL(client, PMAPPROC_DUMP, ...
! 84: // ourselves?)
! 85: //xdr_free((xdrproc_t)xdr_pmaplist, &pl);
! 86:
! 87: if(sin.sin_port == 0)
! 88: {
! 89: // Couldn't get port for rpc call.
! 90: sock = -1;
! 91: return;
! 92: }
! 93: int insock = socket(PF_INET, SOCK_STREAM, 0);
! 94: if (insock < 0)
! 95: {
! 96: sock = -2;
! 97: return;
! 98: }
! 99: if (connect(insock, (const struct sockaddr *)&sin, sizeof(sin)) < 0)
! 100: {
! 101: close(insock);
! 102: sock = -3;
! 103: return;
! 104: }
! 105:
! 106: // If we're version 1, we're going to use the inet socket for
! 107: // communicating with fam, so we're done.
! 108: if (bestvers == 1)
! 109: {
! 110: sock = insock;
! 111: return;
! 112: }
! 113:
! 114: // If we're still here, we want to request a unix domain socket from
! 115: // fam, and use that for communicating. The "N" message with a group
! 116: // list (sort of) is how we tell fam we're version 2.
! 117: char msg[200];
! 118: snprintf(msg + sizeof(u_int32_t), sizeof(msg) - sizeof(u_int32_t),
! 119: "N0 %d %d sockmeister%c0\n", geteuid(), getegid(), '\0');
! 120: int len = strlen(msg + sizeof(u_int32_t)) + 1;
! 121: len += (strlen(msg + sizeof(u_int32_t) + len) + 1);
! 122: u_int32_t nmsglen = htonl(len);
! 123: memcpy(msg, &nmsglen, sizeof(u_int32_t));
! 124: len += sizeof(u_int32_t);
! 125: if (write(insock, msg, len) != len)
! 126: {
! 127: close(insock);
! 128: sock = -6;
! 129: return;
! 130: }
! 131:
! 132: struct sockaddr_un sun;
! 133: memset(&sun, 0, sizeof sun);
! 134: sun.sun_family = AF_UNIX;
! 135:
! 136: // We will block here, waiting for response from fam.
! 137: unsigned int nread = 0;
! 138: char inbuf[sizeof(sun.sun_path)];
! 139: while(nread < sizeof(u_int32_t))
! 140: {
! 141: int rv = read(insock, inbuf + nread, sizeof(u_int32_t) - nread);
! 142: if (rv <= 0)
! 143: {
! 144: close(insock);
! 145: sock = -7;
! 146: return;
! 147: }
! 148: nread += rv;
! 149: }
! 150: u_int32_t mlen;
! 151: memcpy(&mlen, inbuf, sizeof(mlen));
! 152: mlen = ntohl(mlen);
! 153: if (mlen >= sizeof(sun.sun_path))
! 154: {
! 155: close(insock);
! 156: sock = -8;
! 157: return;
! 158: }
! 159:
! 160: nread = 0;
! 161: while (nread < mlen)
! 162: {
! 163: int rv = read(insock, inbuf + nread, mlen - nread);
! 164: if (rv <= 0)
! 165: {
! 166: close(insock);
! 167: sock = -9;
! 168: return;
! 169: }
! 170: nread += rv;
! 171: }
! 172: strncpy(sun.sun_path, inbuf, mlen);
! 173: sun.sun_path[mlen] = '\0';
! 174:
! 175: // When we connected to the inet socket and told fam our UID, fam
! 176: // created a new UNIX domain socket and sent its name to us. Now
! 177: // let's connect on that socket and return.
! 178: sock = socket(PF_UNIX, SOCK_STREAM, 0);
! 179: if (sock < 0)
! 180: {
! 181: close(insock);
! 182: sock = -10;
! 183: return;
! 184: }
! 185: if (connect(sock, (const struct sockaddr *)&sun, sizeof(sun)) < 0)
! 186: {
! 187: close(sock);
! 188: close(insock);
! 189: sock = -11;
! 190: return;
! 191: }
! 192: // all done on the inet sock
! 193: close(insock);
! 194: }
! 195:
! 196: Client::~Client()
! 197: {
! 198: if(sock >= 0) close(sock);
! 199: if(userData != NULL) delete userData;
! 200: if(endExist != NULL) delete endExist;
! 201: }
! 202:
! 203: int
! 204: Client::writeToServer(char *buf, int nbytes)
! 205: {
! 206: if (!connected()) return -1;
! 207: char msgHeader[sizeof(u_int32_t)];
! 208: nbytes = htonl(nbytes);
! 209: memcpy(msgHeader, &nbytes, sizeof(u_int32_t));
! 210: nbytes = ntohl(nbytes);
! 211: if(write(sock, msgHeader, sizeof(u_int32_t)) != sizeof(u_int32_t))
! 212: {
! 213: return -1;
! 214: }
! 215: return write(sock, buf, nbytes);
! 216: }
! 217:
! 218: int
! 219: Client::eventPending()
! 220: {
! 221: if (readEvent(false) < 0) return 1; // EOF or error
! 222: return haveCompleteEvent ? 1 : 0;
! 223: }
! 224:
! 225: int
! 226: Client::nextEvent(FAMEvent *fe)
! 227: {
! 228: if (!connected()) return -1;
! 229: if ((!haveCompleteEvent) && (readEvent(true) < 0))
! 230: {
! 231: // EOF now
! 232: return -1;
! 233: }
! 234: // readEvent(true) blocks until we have a complete event or EOF.
! 235:
! 236: u_int32_t msglen;
! 237: getword(inbuf, &msglen);
! 238:
! 239: char *p = inbuf + sizeof (u_int32_t), *q;
! 240: int limit;
! 241: //
! 242: char code, changeInfo[100];
! 243: int reqnum;
! 244:
! 245: code = *p++;
! 246: reqnum = strtol(p, &q, 10);
! 247: if (p == q)
! 248: {
! 249: croakConnection("Couldn't find reqnum in message!");
! 250: return -1;
! 251: }
! 252: // XXX it would be nice to make sure reqnum is valid, but we only store
! 253: // it if they gave us user data or if it needs an endexists message
! 254: fe->fr.reqnum = reqnum;
! 255: fe->userdata = getUserData(reqnum);
! 256: p = q;
! 257: p++;
! 258: if (code == 'c')
! 259: {
! 260: q = changeInfo;
! 261: limit = sizeof(changeInfo);
! 262: while ((*p != '\0') && (!isspace(*p)) && (--limit)) *q++ = *p++;
! 263: if (!limit)
! 264: {
! 265: char msg[100];
! 266: snprintf(msg, sizeof(msg),
! 267: "change info too long! (%d max)", sizeof(changeInfo));
! 268: croakConnection(msg);
! 269: return -1;
! 270: }
! 271: *q = '\0';
! 272: while (isspace(*p)) ++p;
! 273: }
! 274:
! 275: q = fe->filename;
! 276: limit = PATH_MAX;
! 277: while ((*p != '\0') && (*p != '\n') && (--limit)) *q++ = *p++;
! 278: if (!limit)
! 279: {
! 280: char msg[100];
! 281: snprintf(msg, sizeof(msg), "path too long! (%d max)", PATH_MAX);
! 282: croakConnection(msg);
! 283: return -1;
! 284: }
! 285: *q = '\0';
! 286:
! 287: switch (code) {
! 288: case 'c': // change
! 289: fe->code = FAMChanged;
! 290: break;
! 291: case 'A': // delete
! 292: fe->code = FAMDeleted;
! 293: break;
! 294: case 'X': // start execute
! 295: fe->code = FAMStartExecuting;
! 296: break;
! 297: case 'Q': // quit execute
! 298: fe->code = FAMStopExecuting;
! 299: break;
! 300: case 'F':
! 301: fe->code = getEndExist(reqnum) ? FAMCreated : FAMExists;
! 302: break;
! 303: case 'G':
! 304: // XXX we should be able to free the user data here
! 305: freeRequest(reqnum);
! 306: fe->code = FAMAcknowledge;
! 307: break;
! 308: case 'e': // new - XXX what about exists ?
! 309: fe->code = getEndExist(reqnum) ? FAMCreated : FAMExists;
! 310: break;
! 311: case 'P':
! 312: fe->code = FAMEndExist;
! 313: storeEndExist(reqnum);
! 314: break;
! 315: default:
! 316: snprintf(changeInfo, sizeof(changeInfo),
! 317: "unrecognized code '%c'!", code);
! 318: croakConnection(changeInfo);
! 319: return -1;
! 320: }
! 321: #ifdef DEBUG
! 322: printf("\nFAM received %s ", msg);
! 323: printf("translated to event code:%d, reqnum:%d, ud:%d, filename:<%s>\n",
! 324: fe->code, reqnum, fe->userdata, fe->filename);
! 325: #endif
! 326:
! 327: // Now that we've copied the contents out of this message, slide the
! 328: // contents of the buffer over. Crude, but easier than letting the
! 329: // buffer wrap.
! 330: msglen += sizeof(u_int32_t); // include the size now; less math
! 331: memmove(inbuf, inbuf + msglen, inend - inbuf - msglen);
! 332: inend -= msglen;
! 333: checkBufferForEvent();
! 334:
! 335: return 1;
! 336: }
! 337:
! 338: void
! 339: Client::storeUserData(int reqnum, void *p)
! 340: {
! 341: if(p == NULL) return;
! 342: if(userData == NULL) userData = new BTree<int, void *>();
! 343: userData->insert(reqnum, p);
! 344: }
! 345:
! 346: void *
! 347: Client::getUserData(int reqnum)
! 348: {
! 349: if(userData == NULL) return NULL;
! 350: return userData->find(reqnum);
! 351: }
! 352:
! 353: void
! 354: Client::storeEndExist(int reqnum)
! 355: {
! 356: // It's actually kind of dumb to use a BTree for this, since the only
! 357: // value we ever store will be "true", but access should be fast.
! 358: // I'm not sure whether or not we'll tend to have a lot of requests
! 359: // stored at a time, though.
! 360: if(endExist == NULL) endExist = new BTree<int, bool>();
! 361: endExist->insert(reqnum, true);
! 362: }
! 363:
! 364: bool
! 365: Client::getEndExist(int reqnum)
! 366: {
! 367: if(endExist == NULL) return false;
! 368: return endExist->find(reqnum);
! 369: }
! 370:
! 371: void
! 372: Client::freeRequest(int reqnum)
! 373: {
! 374: if(userData != NULL) userData->remove(reqnum);
! 375: if(endExist != NULL) endExist->remove(reqnum);
! 376: }
! 377:
! 378: int
! 379: Client::readEvent(bool block)
! 380: {
! 381: if (!connected()) return -1;
! 382: if (haveCompleteEvent) return 0;
! 383:
! 384: if (!block)
! 385: {
! 386: fd_set tfds;
! 387: struct timeval tv = { 0, 0 };
! 388: FD_ZERO(&tfds);
! 389: FD_SET(sock, &tfds);
! 390: if (select(sock + 1, &tfds, NULL, NULL, &tv) < 1) return 0;
! 391: }
! 392:
! 393: do
! 394: {
! 395: int rc = read(sock, inend, MSGBUFSIZ - (inend - inbuf));
! 396: if (rc <= 0) return -1; // EOF now
! 397: inend += rc;
! 398: checkBufferForEvent();
! 399: } while (block && !haveCompleteEvent);
! 400:
! 401: return 0;
! 402: }
! 403:
! 404: void
! 405: Client::checkBufferForEvent()
! 406: {
! 407: if (!connected()) return;
! 408: haveCompleteEvent = false;
! 409: u_int32_t msglen = 0;
! 410: if ((inend - inbuf) <= (int)sizeof(u_int32_t)) return;
! 411: getword(inbuf, &msglen);
! 412: if((msglen == 0) || (msglen > MAXMSGSIZ))
! 413: {
! 414: char msg[100];
! 415: snprintf(msg, sizeof(msg), "bad message size! (%d max)", MAXMSGSIZ);
! 416: croakConnection(msg);
! 417: return;
! 418: }
! 419:
! 420: if (inend - inbuf >= (int)msglen + (int)sizeof(u_int32_t))
! 421: {
! 422: haveCompleteEvent = true;
! 423: }
! 424: }
! 425:
! 426: void
! 427: Client::croakConnection(const char *reason)
! 428: {
! 429: if (!connected()) return;
! 430: syslog(LOG_ERR, "libfam killing connection: %s", reason);
! 431: close(sock);
! 432: sock = -1;
! 433: haveCompleteEvent = false;
! 434: }
! 435:
! 436:
! 437: static void
! 438: getword(const char *p, u_int32_t *l)
! 439: {
! 440: memcpy(l, p, sizeof(u_int32_t));
! 441: *l = ntohl(*l);
! 442: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to Client.c++ CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [Development] / fam / libfam