[BACK]Return to rumpclient.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / lib / librumpclient

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/lib/librumpclient/rumpclient.c between version 1.28 and 1.29

version 1.28, 2011/02/14 14:56:23 version 1.29, 2011/02/15 10:37:07
Line 84  static int kq = -1;
Line 84  static int kq = -1;
 static sigset_t fullset;  static sigset_t fullset;
   
 static int doconnect(bool);  static int doconnect(bool);
 static int handshake_req(struct spclient *, uint32_t *, int, bool);  static int handshake_req(struct spclient *, int, void *, int, bool);
   
 time_t retrytimo = RUMPCLIENT_RETRYCONN_ONCE;  time_t retrytimo = RUMPCLIENT_RETRYCONN_ONCE;
   
Line 146  send_with_recon(struct spclient *spc, co
Line 146  send_with_recon(struct spclient *spc, co
   
                         if ((rv = doconnect(false)) != 0)                          if ((rv = doconnect(false)) != 0)
                                 continue;                                  continue;
                         if ((rv = handshake_req(&clispc, NULL, 0, true)) != 0)                          if ((rv = handshake_req(&clispc, HANDSHAKE_GUEST,
                               NULL, 0, true)) != 0)
                                 continue;                                  continue;
   
                         /*                          /*
Line 305  syscall_req(struct spclient *spc, sigset
Line 306  syscall_req(struct spclient *spc, sigset
 }  }
   
 static int  static int
 handshake_req(struct spclient *spc, uint32_t *auth, int cancel, bool haslock)  handshake_req(struct spclient *spc, int type, void *data,
           int cancel, bool haslock)
 {  {
         struct handshake_fork rf;          struct handshake_fork rf;
         struct rsp_hdr rhdr;          struct rsp_hdr rhdr;
Line 314  handshake_req(struct spclient *spc, uint
Line 316  handshake_req(struct spclient *spc, uint
         size_t bonus;          size_t bonus;
         int rv;          int rv;
   
         if (auth) {          if (type == HANDSHAKE_FORK) {
                 bonus = sizeof(rf);                  bonus = sizeof(rf);
         } else {          } else {
                 bonus = strlen(getprogname())+1;                  bonus = strlen(getprogname())+1;
Line 324  handshake_req(struct spclient *spc, uint
Line 326  handshake_req(struct spclient *spc, uint
         rhdr.rsp_len = sizeof(rhdr) + bonus;          rhdr.rsp_len = sizeof(rhdr) + bonus;
         rhdr.rsp_class = RUMPSP_REQ;          rhdr.rsp_class = RUMPSP_REQ;
         rhdr.rsp_type = RUMPSP_HANDSHAKE;          rhdr.rsp_type = RUMPSP_HANDSHAKE;
         if (auth)          rhdr.rsp_handshake = type;
                 rhdr.rsp_handshake = HANDSHAKE_FORK;  
         else  
                 rhdr.rsp_handshake = HANDSHAKE_GUEST;  
   
         pthread_sigmask(SIG_SETMASK, &fullset, &omask);          pthread_sigmask(SIG_SETMASK, &fullset, &omask);
         if (haslock)          if (haslock)
Line 335  handshake_req(struct spclient *spc, uint
Line 334  handshake_req(struct spclient *spc, uint
         else          else
                 putwait(spc, &rw, &rhdr);                  putwait(spc, &rw, &rhdr);
         rv = dosend(spc, &rhdr, sizeof(rhdr));          rv = dosend(spc, &rhdr, sizeof(rhdr));
         if (auth) {          if (type == HANDSHAKE_FORK) {
                 memcpy(rf.rf_auth, auth, AUTHLEN*sizeof(*auth));                  memcpy(rf.rf_auth, data, sizeof(rf.rf_auth)); /* uh, why? */
                 rf.rf_cancel = cancel;                  rf.rf_cancel = cancel;
                 rv = send_with_recon(spc, &rf, sizeof(rf));                  rv = send_with_recon(spc, &rf, sizeof(rf));
         } else {          } else {
Line 710  doinit(void)
Line 709  doinit(void)
 }  }
   
 void *(*rumpclient_dlsym)(void *, const char *);  void *(*rumpclient_dlsym)(void *, const char *);
   static int init_done = 0;
   
 int  int
 rumpclient_init()  rumpclient_init()
 {  {
         char *p;          char *p;
         int error;          int error;
           int rv = -1;
           int hstype;
   
           if (init_done)
                   return 0;
           init_done = 1;
   
         sigfillset(&fullset);          sigfillset(&fullset);
   
Line 753  rumpclient_init()
Line 759  rumpclient_init()
         if ((p = getenv("RUMP__PARSEDSERVER")) == NULL) {          if ((p = getenv("RUMP__PARSEDSERVER")) == NULL) {
                 if ((p = getenv("RUMP_SERVER")) == NULL) {                  if ((p = getenv("RUMP_SERVER")) == NULL) {
                         errno = ENOENT;                          errno = ENOENT;
                         return -1;                          goto out;
                 }                  }
         }          }
   
         if ((error = parseurl(p, &serv_sa, &ptab_idx, 0)) != 0) {          if ((error = parseurl(p, &serv_sa, &ptab_idx, 0)) != 0) {
                 errno = error;                  errno = error;
                 return -1;                  goto out;
         }          }
   
         if (doinit() == -1)          if (doinit() == -1)
                 return -1;                  goto out;
   
         if ((p = getenv("RUMPCLIENT__EXECFD")) != NULL) {          if ((p = getenv("RUMPCLIENT__EXECFD")) != NULL) {
                 sscanf(p, "%d,%d", &clispc.spc_fd, &kq);                  sscanf(p, "%d,%d", &clispc.spc_fd, &kq);
                 unsetenv("RUMPCLIENT__EXECFD");                  unsetenv("RUMPCLIENT__EXECFD");
                 return 0;                  hstype = HANDSHAKE_EXEC;
           } else {
                   if (doconnect(true) == -1)
                           goto out;
                   hstype = HANDSHAKE_GUEST;
         }          }
   
         if (doconnect(true) == -1)          error = handshake_req(&clispc, hstype, NULL, 0, false);
                 return -1;  
   
         error = handshake_req(&clispc, NULL, 0, false);  
         if (error) {          if (error) {
                 pthread_mutex_destroy(&clispc.spc_mtx);                  pthread_mutex_destroy(&clispc.spc_mtx);
                 pthread_cond_destroy(&clispc.spc_cv);                  pthread_cond_destroy(&clispc.spc_cv);
                 if (clispc.spc_fd != -1)                  if (clispc.spc_fd != -1)
                         host_close(clispc.spc_fd);                          host_close(clispc.spc_fd);
                 errno = error;                  errno = error;
                 return -1;                  goto out;
         }          }
           rv = 0;
   
         return 0;   out:
           if (rv == -1)
                   init_done = 0;
           return rv;
 }  }
   
 struct rumpclient_fork {  struct rumpclient_fork {
Line 836  rumpclient_fork_init(struct rumpclient_f
Line 847  rumpclient_fork_init(struct rumpclient_f
         if (doconnect(false) == -1)          if (doconnect(false) == -1)
                 return -1;                  return -1;
   
         error = handshake_req(&clispc, rpf->fork_auth, 0, false);          error = handshake_req(&clispc, HANDSHAKE_FORK, rpf->fork_auth,
               0, false);
         if (error) {          if (error) {
                 pthread_mutex_destroy(&clispc.spc_mtx);                  pthread_mutex_destroy(&clispc.spc_mtx);
                 pthread_cond_destroy(&clispc.spc_cv);                  pthread_cond_destroy(&clispc.spc_cv);

Legend:
Removed from v.1.28  
changed lines
  Added in v.1.29

CVSweb <webmaster@jp.NetBSD.org>