void *handle_client(void *arg) { int i, fd = *(int*)arg; if (nwrite(fd, &i, sizeof(int)) == -1) { perror("write"); goto ERROR; } for (i = 0; i < NUM_CACL; i++) { int a, b, c; if (nread(fd, &a, sizeof(int)) == -1 || nread(fd, &b, sizeof(int)) == -1) { perror("read"); LOCK_INC(calc_fail_count); goto ERROR; } a = ntohl(a); b = ntohl(b); c = htonl(a + b); if (nwrite(fd, &c, sizeof(int)) == -1) { perror("write"); LOCK_INC(calc_fail_count); goto ERROR; } LOCK_INC(calc_success_count); } ERROR: close(fd); free(arg); return NULL; }
void run(int fd) { u_int16_t len; unsigned char *buffer; int loggedin; while(1) { nread(fd, &len, sizeof(len)); len = ntohs(len); buffer = malloc(len); if(! buffer) errx(1, "malloc failure for %d bytes", len); nread(fd, buffer, len); switch(buffer[0]) { case 23: loggedin = login(buffer + 1, len - 1); send_string(fd, 33, loggedin ? "successful" : "failed"); break; default: send_string(fd, 58, "what you talkin about willis?"); break; } } }
static void exchange_packet(int fd) { char response[SIZE_RESPONSE]; send_packet(fd); nread(fd, response, SIZE_RESPONSE); }
long sockbuf::howmanyc () // return how many chars are available for reading in the input buffer // and the recvbuf of the socket. { std::streamsize theShowMany = showmanyc(); assert (theShowMany < INT_MAX); return (long)theShowMany + nread (); }
int md_read(char *buf, int bytes, int *source, int *type, int *flag) { int i; i = nread(buf, bytes, source, type, flag); return i; } /* md_read */
int readreq() { int r; if (skipsp()) goto readend; c = suck(); if (c == EOF) goto readend; if (c == '\n') goto readend; if (c == '.') { while (1) { c = suck(); if (c == EOF) break; if (c == '\n') break; } goto readend; } r = c << 9; c = suck(); if (c != EOF) { if (c != '\n') { r = r | c; } } if (r==0157150) c = tread(ohead); /* oh */ if (r==0163160) { /* sp */ o_sp=nread(); writebreak(); } if (r==0164141) do_ta(); /* ta */ if (r==0165154) o_ul=nread(); /* ul */ while (1) { if (c == EOF) break; if (c == '\n') break; c= suck(); } readend: if (c != EOF) return(1); else return(0); }
static ber_slen_t sb_stream_read( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len ) { assert( sbiod != NULL); assert( SOCKBUF_VALID( sbiod->sbiod_sb ) ); #if defined(MACOS) /* * MacTCP/OpenTransport */ return tcpread( sbiod->sbiod_sb->sb_fd, 0, (unsigned char *)buf, len, NULL ); #elif defined( HAVE_PCNFS ) || \ defined( HAVE_WINSOCK ) || defined ( __BEOS__ ) /* * PCNFS (under DOS) */ /* * Windows Socket API (under DOS/Windows 3.x) */ /* * 32-bit Windows Socket API (under Windows NT or Windows 95) */ { int rc; rc = recv( sbiod->sbiod_sb->sb_fd, buf, len, 0 ); #ifdef HAVE_WINSOCK if ( rc < 0 ) { int err; err = WSAGetLastError(); errno = err; } #endif return rc; } #elif defined( HAVE_NCSA ) /* * NCSA Telnet TCP/IP stack (under DOS) */ return nread( sbiod->sbiod_sb->sb_fd, buf, len ); #else return read( sbiod->sbiod_sb->sb_fd, buf, len ); #endif }
void do_ta() { int v; n_ta = 0; while(1) { v=nread(v); if (v == 1) return; else { o_ta[n_ta] = v; n_ta++; } if (c == '\n') break; if (c == EOF) break; } }
int main(void) { int sock_fd; if( (sock_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) ERR_EXIT("socket"); struct sockaddr_in srv_addr; memset(&srv_addr, 0, sizeof(srv_addr)); srv_addr.sin_family = AF_INET; srv_addr.sin_port = htons(5566); srv_addr.sin_addr.s_addr = htonl(INADDR_ANY); if(bind(sock_fd,(struct sockaddr *)&srv_addr, sizeof(srv_addr)) < 0) ERR_EXIT("bind"); if(listen(sock_fd, SOMAXCONN) < 0) ERR_EXIT("listen"); int conn; int len = sizeof(srv_addr); if( (conn = accept(sock_fd, (struct sockaddr *)&srv_addr, &len)) < 0) ERR_EXIT("accept"); char recvbuf[1024] = {0}; char sendbuf[1024] = {0}; while(1) { memset(recvbuf, 0, sizeof(recvbuf)); int ret = nread(conn, recvbuf, sizeof(recvbuf)); if(ret < 0) { close(sock_fd); close(conn); ERR_EXIT("nread"); }else if(ret == 0) { printf("Client is closed"); break; } fputs(recvbuf, stdout); ret = nwrite(conn, recvbuf, sizeof(recvbuf)); if(ret < 0) { close(conn); close(sock_fd); ERR_EXIT("nwrite"); } } close(sock_fd); close(conn); }
void cos_init(void) { int i = 0; int ret; int data; void *buf_read, *buf_write; cbuf_t read_buffer, write_buffer; printc("pong init\n"); if (replica_confirm(cos_spd_id())) BUG(); /* Get our buffers*/ write_buffer = get_write_buf(cos_spd_id()); read_buffer = get_read_buf(cos_spd_id()); buf_read = cbuf2buf(read_buffer, 1024); buf_write = cbuf2buf(write_buffer, 1024); printc("pong confirmed with buffers read (%d) and write(%d)\n", read_buffer, write_buffer); confirm_fork(cos_spd_id()); while (i < N_ROUNDS) { printc("\ni = %d, pong calling read from spdid %d\n", i, cos_spd_id()); ret = nread(cos_spd_id(), 0, 1); assert(ret); data = *((int *) buf_read); printc("Thread %d: read returned %d and now we have data [%d]\n\n", cos_get_thd_id(), ret, data++); printc("\ni = %d, pong calling write\n", i); memcpy(buf_write, (void*)&data, 1); ret = nwrite(cos_spd_id(), 1, 1); assert(ret); printc("Thread %d: write returned %d\n\n", cos_get_thd_id(), ret); i++; } /* * This will actually never execute because this thread was put to sleep and once the last spd returns and exits, nothing is there to wake it up * (minor edge case, voter_monitor would be the ideal place to fix */ printc("Spdid %d finished.\n", cos_spd_id()); }
int load_gesture_entry(int fd, PGconn* conn, int store_id) { struct gesture_entry entry; GET(fd, entry.name_len); deflip16(entry.name_len); entry.name = calloc(entry.name_len+1, 1); nread(fd, entry.name, entry.name_len); entry.name[entry.name_len] = '\0'; GET(fd, entry.num_gestures); deflip32(entry.num_gestures); int entry_id = PG_EXEC_PARAMS(conn, "INSERT INTO gesture_entries (name, library_id) VALUES($1::text, $2::integer) RETURNING id", entry.name, itoa(store_id)); for (ssize_t i = 0; i < entry.num_gestures; i++) if (load_gesture(fd, conn, entry_id) != 0) return 1; return 0; }
int md_wrap_wait(void *buf, int bytes, int *source, int *type, int *flag, MPI_Request *request) /******************************************************************************* Machine dependent wrapped message-wait communication routine for the Intel. This routine is identical to md_read but is put here in order to be compatible with the order required to do MPI communication. Author: Scott A. Hutchinson, SNL, 9221 ======= Return code: int ============ Parameter list: =============== buf: Beginning address of data to be sent. bytes: Length of message in bytes. dest: Destination processor number. type: Message type flag: *******************************************************************************/ { int i; i = nread(buf, bytes, source, type, flag); return i; } /* md_wrap_wait */
static ber_slen_t sb_stream_read( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len ) { assert( sbiod != NULL); assert( SOCKBUF_VALID( sbiod->sbiod_sb ) ); #if defined(MACOS) /* * MacTCP/OpenTransport */ return tcpread( sbiod->sbiod_sb->sb_fd, 0, (unsigned char *)buf, len, NULL ); #elif defined( HAVE_PCNFS ) || \ defined( HAVE_WINSOCK ) || defined ( __BEOS__ ) /* * PCNFS (under DOS) */ /* * Windows Socket API (under DOS/Windows 3.x) */ /* * 32-bit Windows Socket API (under Windows NT or Windows 95) */ return recv( sbiod->sbiod_sb->sb_fd, (char*)buf, (int)len, 0 ); // This should be safe, as ret will not exceed 2G. #elif defined( HAVE_NCSA ) /* * NCSA Telnet TCP/IP stack (under DOS) */ return nread( sbiod->sbiod_sb->sb_fd, buf, len ); #else return read( sbiod->sbiod_sb->sb_fd, buf, len ); #endif }
static void *_thread_working(void *arg) { int fd = _fd; while (1) { _failed: usleep(1000); struct serial_request *req = queue_pop(_Q, NULL); if (_check_command(req->buf, req->sz) == 0) { log_err("cmd error\n"); free(req); goto _failed; } int num = 0; if (req->buf[1] == 0x30) { // DATA size + STX(1 byte) + ETX(1 byte) + SUM(2 byte) num = ((req->buf[6]-'0')*10 + (req->buf[7]-'0'))*2+4; } else { num = 1; } if (num > 64*2+4) { log_err("cmd error\n"); free(req); goto _failed; } // write command int ret = nwrite(fd, req->buf, req->sz); if (ret < 0) { log_err("serial error\n"); free(req); goto _failed; } _S->n_send++; char resp[4096]; memset(resp, 0, sizeof(resp)); for (;;) { struct timeval tv; memset(&tv, 0, sizeof(struct timeval)); tv.tv_sec = 5; tv.tv_usec = 0; fd_set rfds; FD_ZERO(&rfds); FD_SET(fd, &rfds); ret = select(fd+1, &rfds, NULL, NULL, &tv); if (ret == -1) { log_err("select error\n"); free(req); goto _failed; } else if (ret == 0) { log_err("time expired\n"); free(req); goto _failed; } else { int cnt = nread(fd, resp, num); if (cnt == -1) { log_err("serial error\n"); free(req); goto _failed; } // call cb _S->n_recv++; req->cb(req->ud, resp, num); break; } } // free something free(req); } return (void *)NULL; }
int main(int argc,char *argv[]){ int i,fd,nmaxconn,nfiles,maxfd,nconn,flags; char buf[MAXLINE]; fd_set rs,ws; if(argc < 4) err_quit("usage : web <#conn> hostname homepage file1 ..."); nmaxconn = atoi(argv[1]); nfiles = min(argc-4,MAXFILES); for(i=0;i<nfiles;i++){ file[i].f_name = argv[4+i]; file[i].f_host = argv[2]; file[i].flags = 0; } home_page(argv[2],argv[3]); FD_ZERO(&rs); FD_ZERO(&ws); maxfd = -1; nconn = 0; nleftconn = nlefttoread = nfiles; while(nlefttoread > 0){ while(nconn < nmaxconn && nleftconn > 0){ for(i=0;i<nfiles;i++) if(file[i].flags != 0) break; if(i == nfiles) err_quit("nleftconn = %d but nothing found\n",nleftconn); start_connect(&file[i]); nconn++; nleftconn--; } rs = rset; ws = wset; Select(maxfd+1,&rset,&wset,NULL,NULL); for(i=0;i<nfiles;i++){ flags = file[i].flags; if(flags == 0 || flags == F_DONE) continue; fd = file[i].f_fd; if(flags & F_CONNECTING && (FD_ISSET(fd,&rset) || FD_ISSET(fd,&wset))){ n=sizeof(error); if(getsockopt(fd,SOL_SOCKET,SO_ERROR,&error,&n) < 0 || error != 0) err_ret("nonblocking connect failed for %s\n",file[i].f_name); printf("connection established for %s\n",file[i].f_name); FD_CLR(fd,&wset); write_get_cmd(&file[i]); }else if(flags & F_READING && FD_ISSET(fd,&rset)){ if((n = nread(fd,buf,sizeof(buf))) == 0){ printf("end-of-file on %s\n",file[i].f_name); Close(fd); file[i].flags = F_DONE; FD_CLR(fd,&rset); nconn--; nlefconn--; nlefttoread--; }else { printf("read %d bytes from %s\n",n,file[i].f_name); } } } } exit(0); }
int ploop_copy_receiver(struct ploop_copy_receive_param *arg) { int ofd, ret; __u64 cluster = 0; void *iobuf = NULL; int n; struct pcopy_pkt_desc desc; if (!arg) return SYSEXIT_PARAM; if (is_fd_socket(arg->ifd) != 1) { ploop_err(errno, "Invalid input fd %d: must be " "a pipe or a socket", arg->ifd); return SYSEXIT_PARAM; } ofd = open(arg->file, O_WRONLY|O_CREAT|O_TRUNC, 0600); if (ofd < 0) { ploop_err(errno, "Can't open %s", arg->file); return SYSEXIT_CREAT; } ploop_dbg(3, "RCV start %s", arg->file); for (;;) { if (nread(arg->ifd, &desc, sizeof(desc)) < 0) { ploop_err(errno, "Error in nread(desc)"); ret = SYSEXIT_READ; goto out; } if (desc.marker != PCOPY_MARKER) { ploop_err(0, "Stream corrupted"); ret = SYSEXIT_PROTOCOL; goto out; } if (desc.size > cluster) { free(iobuf); iobuf = NULL; cluster = desc.size; if (p_memalign(&iobuf, 4096, cluster)) { ret = SYSEXIT_MALLOC; goto out; } } if (desc.size == 0) break; if (nread(arg->ifd, iobuf, desc.size)) { ploop_err(errno, "Error in nread data"); ret = SYSEXIT_READ; goto out; } ploop_log(3, "RCV type=%d len=%d pos=%" PRIu64, desc.type, desc.size, (uint64_t)desc.pos); ret = 0; switch (desc.type) { case PCOPY_PKT_DATA: case PCOPY_PKT_DATA_ASYNC: { n = TEMP_FAILURE_RETRY(pwrite(ofd, iobuf, desc.size, desc.pos)); if (n != desc.size) { if (n < 0) ploop_err(errno, "Error in pwrite"); else ploop_err(0, "Error: short pwrite"); ret = SYSEXIT_WRITE; goto out; } break; } case PCOPY_PKT_CMD: { unsigned int cmd = ((unsigned int *) iobuf)[0]; switch(cmd) { case PCOPY_CMD_SYNC: ret = data_sync(ofd); if (ret) goto out; break; default: ploop_err(0, "ploop_copy_receiver: unsupported command %d", cmd); ret = SYSEXIT_PARAM; } break; } default: ploop_err(0, "ploop_copy_receiver: unsupported command type%d", desc.type); ret = SYSEXIT_PARAM; break; } /* send reply */ if (desc.type != PCOPY_PKT_DATA_ASYNC && nwrite(arg->ifd, &ret, sizeof(int))) { ret = SYSEXIT_WRITE; ploop_err(errno, "failed to send reply"); goto out; } } ret = data_sync(ofd); if (ret) goto out; ploop_dbg(3, "RCV exited"); /* send final reply */ ret = 0; if (nwrite(arg->ifd, &ret, sizeof(int))) { ret = SYSEXIT_WRITE; ploop_err(errno, "failed to send reply"); goto out; } out: if (close(ofd)) { ploop_err(errno, "Error in close"); if (!ret) ret = SYSEXIT_WRITE; } if (ret) unlink(arg->file); free(iobuf); return ret; }
int main(void) { int sock_fd; if( (sock_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) ERR_EXIT("socket"); struct sockaddr_in srv_addr; memset(&srv_addr, 0, sizeof(srv_addr)); srv_addr.sin_family = AF_INET; srv_addr.sin_port = htons(5566); srv_addr.sin_addr.s_addr = htonl(INADDR_ANY); if(bind(sock_fd,(struct sockaddr *)&srv_addr, sizeof(srv_addr)) < 0) ERR_EXIT("bind"); if(listen(sock_fd, SOMAXCONN) < 0) ERR_EXIT("listen"); int conn; int len = sizeof(srv_addr); int client[FD_SETSIZE]; int i; memset(client, -1, sizeof(client)); fd_set allset; fd_set set; FD_ZERO(&set); FD_ZERO(&allset); FD_SET(sock_fd, &allset); set = allset; int maxfd = sock_fd + 1; while(1){ set = allset; int nready = select(maxfd, &set, NULL, NULL, NULL); if( nready < 0 ) { if(errno == EINTR) continue; ERR_EXIT("select"); }else if(nready == 0) continue; if(nready > 0) { if(FD_ISSET(sock_fd, &set)) { if((conn = accept(sock_fd, (struct sockaddr *)&srv_addr, &len)) < 0) ERR_EXIT("accept"); if(conn >= maxfd) maxfd = conn + 1; for(i=0; i<FD_SETSIZE; i++) { if(client[i] == -1) { client[i] = conn; FD_SET(conn, &allset); break; } } if(i >= FD_SETSIZE) { printf("Too many conn\n"); continue; } if(nready == 0) continue; } char recvbuf[1024] = {0}; for(i=0; i<FD_SETSIZE; i++) { if(FD_ISSET(client[i], &set)) { int ret = nread(client[i], recvbuf, sizeof(recvbuf)); if(ret < 0) { if(errno == EINTR) continue; ERR_EXIT("nread"); }else if(ret == 0) { printf("client is closed\n"); FD_CLR(client[i], &allset); close(client[i]); client[i] = -1; continue; } fputs(recvbuf, stdout); ret = nwrite(client[i], recvbuf, sizeof(recvbuf)); if(ret < 0) { if(errno == EINTR) continue; ERR_EXIT("nwrite"); } } } } } close(sock_fd); return 0; }
eaio::size_type eaio::readLine(IStream* pIS, char16_t* pLine, size_type nMaxCount, Endian endianSource) { char16_t cCurrent; size_type nCount(0); // Number of chars in the line, not including the line end characters(s). size_type nread(0); // Number of chars successfully read from stream. Will be >= nCount (due to presence of newlines). size_type nResult; off_type ninitialPosition(0); char16_t cr, lf; if(!pLine) ninitialPosition = pIS->getPosition(); if(endianSource == kEndianLocal) { cr = '\r'; lf = '\n'; } else { cr = SwizzleUint16('\r'); lf = SwizzleUint16('\n'); } for(;;) { // We are reading one character at a time, which can be slow if the stream is // not buffered. We read one character at a time because we don't want to read // past the end of the line and thus trigger seeks, which may not even be possible // for some streams. nResult = pIS->read(&cCurrent, sizeof(cCurrent)); if(nResult == sizeof(cCurrent)) { ++nread; if((cCurrent == cr) || (cCurrent == lf)) { // It's possible that we have a "\n" or "\r\n" sequence, and we want // to read past the sequence, but not past anything else. This code here takes // care not to read past the first "\n" in a "\n\n" sequence, but is smart // enough to read past the just first "\r\n" in a "\r\n\r\n" sequence. char16_t cNext = cCurrent; if(cCurrent == cr) // If we have a "\r", then we read again, expecting a "\n". nResult = (size_type)pIS->read(&cNext, sizeof(cNext)); if(cNext != lf) { // We have encountered an unexpected sequence: We have a "\rx" instead of "\n" or "\r\n". // This call requires a stream that can back up. pIS->setPosition(-(off_type)sizeof(cNext), kPositionTypeCurrent); } break; } else { if(pLine && (nCount < (nMaxCount - 1))) // '- 1' because we want to leave room for terminating null. { if(endianSource != kEndianLocal) cCurrent = SwizzleUint16(cCurrent); *pLine++ = cCurrent; } ++nCount; } } else { // In this case, there was nothing left to read in the file. // We need to differentiate between an empty line vs. nothing // left to read in the file. To deal with that we return kSizeTypeDone. if(nread == 0) nCount = kSizeTypeDone; break; } } if(pLine) *pLine = 0; else pIS->setPosition(ninitialPosition); return nCount; }
int ploop_copy_receive(struct ploop_copy_receive_param *arg) { int ofd, ret; __u64 cluster = 0; void *iobuf = NULL; if (!arg) return SYSEXIT_PARAM; if (is_fd_pipe(arg->ifd) != 1) { ploop_err(errno, "Invalid input fd %d: must be " "a pipe or a socket", arg->ifd); return SYSEXIT_PARAM; } if (arg->feedback_fd >= 0 && is_fd_pipe(arg->feedback_fd) != 1) { ploop_err(errno, "Invalid feedback fd %d: must be " "a pipe or a socket", arg->feedback_fd); return SYSEXIT_PARAM; } /* If feedback is to be send to stdout or stderr, * we have to disable logging to appropriate fd. * * As currently there's no way to disable just stderr, * so in this case we have to disable stdout as well. */ if (arg->feedback_fd == STDOUT_FILENO) ploop_set_verbose_level(PLOOP_LOG_NOSTDOUT); else if (arg->feedback_fd == STDERR_FILENO) ploop_set_verbose_level(PLOOP_LOG_NOCONSOLE); ofd = open(arg->file, O_WRONLY|O_CREAT|O_EXCL, 0600); if (ofd < 0) { ploop_err(errno, "Can't open %s", arg->file); return SYSEXIT_CREAT; } /* Read data */ for (;;) { int n; struct xfer_desc desc; if (nread(arg->ifd, &desc, sizeof(desc)) < 0) { ploop_err(errno, "Error in nread(desc)"); ret = SYSEXIT_READ; goto out; } if (desc.marker != PLOOPCOPY_MARKER) { ploop_err(0, "Stream corrupted"); ret = SYSEXIT_PROTOCOL; goto out; } if (desc.size > cluster) { free(iobuf); iobuf = NULL; cluster = desc.size; if (p_memalign(&iobuf, 4096, cluster)) { ret = SYSEXIT_MALLOC; goto out; } } if (desc.size == 0) break; if (nread(arg->ifd, iobuf, desc.size)) { ploop_err(errno, "Error in nread data"); ret = SYSEXIT_READ; goto out; } if (desc.size == SYNC_MARK) { int st; /* ignore received data, instead do sync */ st = fdatasync(ofd); if (arg->feedback_fd >= 0) { /* Tell the sending side how it went */ int w; w = write(arg->feedback_fd, st ? STATUS_FAIL : STATUS_OK, LEN_STATUS); /* check write error only if no error yet */ if (!st && w != LEN_STATUS) { ploop_err(errno, "Error in write(%d)", arg->feedback_fd); ret = SYSEXIT_WRITE; goto out; } } if (st) { ploop_err(errno, "Error in fdatasync()"); ret = SYSEXIT_WRITE; goto out; } continue; } n = pwrite(ofd, iobuf, desc.size, desc.pos); if (n != desc.size) { if (n < 0) ploop_err(errno, "Error in pwrite"); else ploop_err(0, "Error: short pwrite"); ret = SYSEXIT_WRITE; goto out; } } if (fdatasync(ofd)) { ploop_err(errno, "Error in fdatasync"); ret = SYSEXIT_WRITE; goto out; } ret = 0; out: if (close(ofd)) { ploop_err(errno, "Error in close"); if (!ret) ret = SYSEXIT_WRITE; } if (ret) unlink(arg->file); free(iobuf); return ret; }