int sock_accept_connection(int purpose) { fd_set rd; int ret_val, i, p; if (getenv("SPADNUM") == NULL) return -1; while (1) { rd = server_mask; ret_val = sselect(FD_SETSIZE, (fd_set *)&rd, (fd_set *)0, (fd_set *)0, NULL); if (ret_val == -1) { /* perror ("Select"); */ return -1; } for(i=0; i<2; i++) { if (is_valid_socket(&server[i]) && FD_ISSET(server[i].socket, &rd)) { p = fricas_accept_connection(server+i); if (p == purpose) return 1; } } } }
/* act as terminal session for sock connected to stdin and stdout of another process */ void remote_stdio(Sock *sock) { char buf[1024]; fd_set rd; int len; while (1) { FD_ZERO(&rd); FD_SET(sock->socket,&rd); FD_SET(0, &rd); len = sselect(FD_SETSIZE, (fd_set *)&rd, (fd_set *)0, (fd_set *)0, NULL); if (len == -1) { perror("stdio select"); return; } if (FD_ISSET(0, &rd)) { fgets(buf,1024,stdin); len = strlen(buf); /* gets(buf); len = strlen(buf); *(buf+len) = '\n'; *(buf+len+1) = '\0'; */ swrite(sock, buf, len, "writing to remote stdin"); } if (FD_ISSET(sock->socket, &rd)) { len = sread(sock, buf, 1024, "stdio"); if (len == -1) return; else { *(buf + len) = '\0'; fputs(buf, stdout); fflush(stdout); } } } }
static void glitch_one_detector( actData *mydat, ///< Data vector to filter. Modified and returned. const actData *filt, ///< The pre-calculated smoothing filter to use. actComplex *tmpfft, ///< Pre-allocated vector of length n. Returns DFT of smoothed data.. actData *tmpvec, ///< Pre-allocated vector of length n. Returns unmodified input. actData *tmpclean, ///< Pre-allocated vector of length n. Returns abs(raw-smooth). int *cutvec, ///< Pre-allocated vector of length n. Returns cut list if (do_cuts). int n, ///< Length of the input data vector mydat. //fftwf_plan p_forward, ///< The FFTW plan for going to the frequency domain. //fftwf_plan p_back, ///< The FFTW plan for going back to the time domain. act_fftw_plan p_forward, ///< The FFTW plan for going to the frequency domain. act_fftw_plan p_back, ///< The FFTW plan for going back to the time domain. bool do_smooth, ///< Whether to replace the entire data vector with its smoothed value. bool apply_glitch, ///< Whether to replace data exceeding the cut threshold with its smoothed value. bool do_cuts, ///< Whether to build the cutvec of data failing the cut threshhold test. actData nsig) ///< The cut threshold is this factor times the median abs deviation of smooths. { // If we have both set to true, we don't know what to put in mydat #ifdef HAVE_PSERR if(do_smooth && apply_glitch) psError(MB_ERR_BAD_VALUE, true, "Cannot both smooth and deglitch (=not smooth) data in glitch_one_detector\n"); #endif // User hasn't requested any action! if (! (do_smooth || apply_glitch || do_cuts)) return; // Save a copy of the input data, then apply the smoothing filter only. memcpy(tmpvec,mydat,n*sizeof(actData)); filter_one_tod(mydat, filt, tmpfft,p_forward,p_back,n); // Joe mystified by this rescaling. #if 1 const actData nf=n; for (int i=0;i<n;i++) mydat[i]/=nf; #endif // If we don't need to know nor apply the cuts, then we're done. if (do_smooth & (!do_cuts)) return; // tmpclean is the absolute difference between smooth and raw vectors. Find its median (for use in cuts). for (int j=0;j<n;j++) tmpclean[j]=fabs(mydat[j]-tmpvec[j]); actData thresh=sselect(n/2,n,tmpclean-1)*nsig; if (do_cuts) { memset(cutvec,0,sizeof(int)*n); for (int j=0;j<n;j++) { if (fabs(mydat[j]-tmpvec[j])>thresh) cutvec[j]=1; } } if (do_smooth) return; // By this point, we know the user didn't want smooth data. Copy data back to the input vector. // If apply_glitch, then mostly this will be the raw data, but we leave the smoothed data there // during all glitches. Otherwise, we want the entire raw data set back (and presumably called // this function only to get the cuts). if (apply_glitch) { for (int j=0;j<n;j++) if (fabs(mydat[j]-tmpvec[j])<thresh) mydat[j]=tmpvec[j]; } else memcpy(mydat,tmpvec,sizeof(actData)*n); }
static int transfer(CLI *c) { /* transfer data */ fd_set rd_set, wr_set; int num, err, fdno; int check_SSL_pending; int ssl_closing; /* 0=not closing SSL, 1=initiate SSL_shutdown, * 2=retry SSL_shutdown, 3=SSL_shutdown done */ int ready; struct timeval tv; /* fdno=max(c->sock_rfd->fd, c->sock_wfd->fd, * fdno=c->ssl_rfd->fd, fdno=c->ssl_wfd->fd)+1 */ fdno=c->sock_rfd->fd; if(c->sock_wfd->fd>fdno) fdno=c->sock_wfd->fd; if(c->ssl_rfd->fd>fdno) fdno=c->ssl_rfd->fd; if(c->ssl_wfd->fd>fdno) fdno=c->ssl_wfd->fd; fdno+=1; c->sock_ptr=c->ssl_ptr=0; sock_rd=sock_wr=ssl_rd=ssl_wr=1; c->sock_bytes=c->ssl_bytes=0; ssl_closing=0; while(((sock_rd||c->sock_ptr)&&ssl_wr)||((ssl_rd||c->ssl_ptr)&&sock_wr)) { FD_ZERO(&rd_set); /* Setup rd_set */ if(sock_rd && c->sock_ptr<BUFFSIZE) /* socket input buffer not full*/ FD_SET(c->sock_rfd->fd, &rd_set); if(ssl_rd && ( c->ssl_ptr<BUFFSIZE || /* SSL input buffer not full */ ((c->sock_ptr||ssl_closing) && SSL_want_read(c->ssl)) /* I want to SSL_write or SSL_shutdown but read from the * underlying socket needed for the SSL protocol */ )) { FD_SET(c->ssl_rfd->fd, &rd_set); } FD_ZERO(&wr_set); /* Setup wr_set */ if(sock_wr && c->ssl_ptr) /* SSL input buffer not empty */ FD_SET(c->sock_wfd->fd, &wr_set); if (ssl_wr && ( c->sock_ptr || /* socket input buffer not empty */ ssl_closing==1 || /* initiate SSL_shutdown */ ((c->ssl_ptr<BUFFSIZE || ssl_closing==2) && SSL_want_write(c->ssl)) /* I want to SSL_read or SSL_shutdown but write to the * underlying socket needed for the SSL protocol */ )) { FD_SET(c->ssl_wfd->fd, &wr_set); } tv.tv_sec=sock_rd || (ssl_wr&&c->sock_ptr) || (sock_wr&&c->ssl_ptr) ? c->opt->timeout_idle : c->opt->timeout_close; tv.tv_usec=0; ready=sselect(fdno, &rd_set, &wr_set, NULL, &tv); if(ready<0) { /* Break the connection for others */ sockerror("select"); return -1; } if(!ready) { /* Timeout */ if(sock_rd) { /* No traffic for a long time */ log(LOG_DEBUG, "select timeout: connection reset"); return -1; } else { /* Timeout waiting for SSL close_notify */ log(LOG_DEBUG, "select timeout waiting for SSL close_notify"); break; /* Leave the while() loop */ } } if(ssl_closing==1 /* initiate SSL_shutdown */ || (ssl_closing==2 && ( (SSL_want_read(c->ssl) && FD_ISSET(c->ssl_rfd->fd, &rd_set)) || (SSL_want_write(c->ssl) && FD_ISSET(c->ssl_wfd->fd, &wr_set)) ))) { switch(SSL_shutdown(c->ssl)) { /* Send close_notify */ case 1: /* the shutdown was successfully completed */ log(LOG_INFO, "SSL_shutdown successfully sent close_notify"); ssl_wr=0; /* SSL write closed */ /* TODO: It's not really closed. We need to distinguish * closed SSL and closed underlying file descriptor */ ssl_closing=3; /* done! */ break; case 0: /* the shutdown is not yet finished */ log(LOG_DEBUG, "SSL_shutdown retrying"); ssl_closing=2; /* next time just retry SSL_shutdown */ break; case -1: /* a fatal error occurred */ sslerror("SSL_shutdown"); return -1; } } /* Set flag to try and read any buffered SSL data if we made */ /* room in the buffer by writing to the socket */ check_SSL_pending = 0; if(sock_wr && FD_ISSET(c->sock_wfd->fd, &wr_set)) { switch(num=writesocket(c->sock_wfd->fd, c->ssl_buff, c->ssl_ptr)) { case -1: /* error */ switch(get_last_socket_error()) { case EINTR: log(LOG_DEBUG, "writesocket interrupted by a signal: retrying"); break; case EWOULDBLOCK: log(LOG_NOTICE, "writesocket would block: retrying"); break; default: sockerror("writesocket"); return -1; } break; case 0: log(LOG_DEBUG, "No data written to the socket: retrying"); break; default: memmove(c->ssl_buff, c->ssl_buff+num, c->ssl_ptr-num); if(c->ssl_ptr==BUFFSIZE) check_SSL_pending=1; c->ssl_ptr-=num; c->sock_bytes+=num; if(!ssl_rd && !c->ssl_ptr) { shutdown(c->sock_wfd->fd, SHUT_WR); log(LOG_DEBUG, "Socket write shutdown (no more data to send)"); sock_wr=0; } } } if(ssl_wr && ( /* SSL sockets are still open */ (c->sock_ptr && FD_ISSET(c->ssl_wfd->fd, &wr_set)) || /* See if application data can be written */ (SSL_want_read(c->ssl) && FD_ISSET(c->ssl_rfd->fd, &rd_set)) /* I want to SSL_write but read from the underlying */ /* socket needed for the SSL protocol */ )) { num=SSL_write(c->ssl, c->sock_buff, c->sock_ptr); err=SSL_get_error(c->ssl, num); switch(err) { case SSL_ERROR_NONE: memmove(c->sock_buff, c->sock_buff+num, c->sock_ptr-num); c->sock_ptr-=num; c->ssl_bytes+=num; if(!ssl_closing && !sock_rd && !c->sock_ptr && ssl_wr) { log(LOG_DEBUG, "SSL write shutdown (no more data to send)"); ssl_closing=1; } break; case SSL_ERROR_WANT_WRITE: case SSL_ERROR_WANT_READ: case SSL_ERROR_WANT_X509_LOOKUP: log(LOG_DEBUG, "SSL_write returned WANT_: retrying"); break; case SSL_ERROR_SYSCALL: if(num<0) { /* really an error */ switch(get_last_socket_error()) { case EINTR: log(LOG_DEBUG, "SSL_write interrupted by a signal: retrying"); break; case EAGAIN: log(LOG_DEBUG, "SSL_write returned EAGAIN: retrying"); break; default: sockerror("SSL_write (ERROR_SYSCALL)"); return -1; } } break; case SSL_ERROR_ZERO_RETURN: /* close_notify received */ log(LOG_DEBUG, "SSL closed on SSL_write"); ssl_rd=ssl_wr=0; break; case SSL_ERROR_SSL: sslerror("SSL_write"); return -1; default: log(LOG_ERR, "SSL_write/SSL_get_error returned %d", err); return -1; } } if(sock_rd && FD_ISSET(c->sock_rfd->fd, &rd_set)) { switch(num=readsocket(c->sock_rfd->fd, c->sock_buff+c->sock_ptr, BUFFSIZE-c->sock_ptr)) { case -1: switch(get_last_socket_error()) { case EINTR: log(LOG_DEBUG, "readsocket interrupted by a signal: retrying"); break; case EWOULDBLOCK: log(LOG_NOTICE, "readsocket would block: retrying"); break; default: sockerror("readsocket"); return -1; } break; case 0: /* close */ log(LOG_DEBUG, "Socket closed on read"); sock_rd=0; if(!ssl_closing && !c->sock_ptr && ssl_wr) { log(LOG_DEBUG, "SSL write shutdown (output buffer empty)"); ssl_closing=1; } break; default: c->sock_ptr+=num; } } if(ssl_rd && ( /* SSL sockets are still open */ (c->ssl_ptr<BUFFSIZE && FD_ISSET(c->ssl_rfd->fd, &rd_set)) || /* See if there's any application data coming in */ (SSL_want_write(c->ssl) && FD_ISSET(c->ssl_wfd->fd, &wr_set)) || /* I want to SSL_read but write to the underlying */ /* socket needed for the SSL protocol */ (check_SSL_pending && SSL_pending(c->ssl)) /* Write made space from full buffer */ )) { num=SSL_read(c->ssl, c->ssl_buff+c->ssl_ptr, BUFFSIZE-c->ssl_ptr); err=SSL_get_error(c->ssl, num); switch(err) { case SSL_ERROR_NONE: c->ssl_ptr+=num; break; case SSL_ERROR_WANT_WRITE: case SSL_ERROR_WANT_READ: case SSL_ERROR_WANT_X509_LOOKUP: log(LOG_DEBUG, "SSL_read returned WANT_: retrying"); break; case SSL_ERROR_SYSCALL: if(num<0) { /* not EOF */ switch(get_last_socket_error()) { case EINTR: log(LOG_DEBUG, "SSL_read interrupted by a signal: retrying"); break; case EAGAIN: log(LOG_DEBUG, "SSL_read returned EAGAIN: retrying"); break; default: sockerror("SSL_read (ERROR_SYSCALL)"); return -1; } } else { /* EOF */ log(LOG_DEBUG, "SSL socket closed on SSL_read"); ssl_rd=ssl_wr=0; } break; case SSL_ERROR_ZERO_RETURN: /* close_notify received */ log(LOG_DEBUG, "SSL closed on SSL_read"); ssl_rd=0; if(!ssl_closing && !c->sock_ptr && ssl_wr) { log(LOG_DEBUG, "SSL write shutdown (output buffer empty)"); ssl_closing=1; } if(!c->ssl_ptr && sock_wr) { shutdown(c->sock_wfd->fd, SHUT_WR); log(LOG_DEBUG, "Socket write shutdown (output buffer empty)"); sock_wr=0; } break; case SSL_ERROR_SSL: sslerror("SSL_read"); return -1; default: log(LOG_ERR, "SSL_read/SSL_get_error returned %d", err); return -1; } } } return 0; /* OK */ }