/* * Gather the fds read from input processes to a single output. */ STATIC void gather_input_fds(struct dgsh_negotiation *mb) { struct dgsh_conc *this_conc = find_conc(mb, pid); if (!this_conc) { printf("%s(): Concentrator with pid %d not registered", __func__, pid); exit(1); // XXX } int n_to_write = this_conc->output_fds; int *read_fds = (int *)malloc(n_to_write * sizeof(int)); int i, j, read_index; DPRINTF(4, "%s(): fds to write: %d", __func__, n_to_write); read_index = 0; for (i = STDIN_FILENO; i < nfd; i == STDIN_FILENO ? i = FREE_FILENO : i++) { int n_to_read = get_provided_fds_n(mb, pi[i].pid); DPRINTF(4, "%s(): fds to read for p[%d].pid %d: %d", __func__, i, pi[i].pid, n_to_read); for (j = read_index; j < read_index + n_to_read; j++) { read_fds[j] = read_fd(i); DPRINTF(4, "%s(): Read fd: %d from input channel: %d", __func__, read_fds[j], i); } read_index += n_to_read; } assert(read_index == n_to_write); for (i = 0; i < n_to_write; i++) write_fd(STDOUT_FILENO, read_fds[i]); }
/* * Scatter the fds read from the input process to multiple outputs. */ STATIC void scatter_input_fds(struct dgsh_negotiation *mb) { struct dgsh_conc *this_conc = find_conc(mb, pid); if (!this_conc) { printf("%s(): Concentrator with pid %d not registered", __func__, pid); exit(1); // XXX } int n_to_read = this_conc->input_fds; int *read_fds = (int *)malloc(n_to_read * sizeof(int)); int i, j, write_index = 0; bool ignore = false; DPRINTF(4, "%s(): fds to read: %d", __func__, n_to_read); for (i = 0; i < n_to_read; i++) read_fds[i] = read_fd(STDIN_FILENO); for (i = STDOUT_FILENO; i != STDIN_FILENO; i = next_fd(i, &ignore)) { int n_to_write = get_expected_fds_n(mb, pi[i].pid); DPRINTF(4, "%s(): fds to write for p[%d].pid %d: %d", __func__, i, pi[i].pid, n_to_write); for (j = write_index; j < write_index + n_to_write; j++) { write_fd(i, read_fds[j]); DPRINTF(4, "%s(): Write fd: %d to output channel: %d", __func__, read_fds[j], i); } write_index += n_to_write; } assert(write_index == n_to_read); }
void ___ylog_write(enum yloglv lv, const char *file, int lineno, const char *fmt, ...) { int r, fd; struct timespec tm; char *buf = get_buffer(); if (unlikely(!buf)) return; /* ignore this log */ if (unlikely(YLOG_VERBOSE > lv || YLOG_FATAL < lv)) return; /* invalid log level. ignore this log */ if (unlikely(clock_gettime(CLOCK_MONOTONIC, &tm))) memset(&tm, 0, sizeof(tm)); /* add log prefix */ r = snprintf(buf, LOG_BUF_SZ, "[%c] %9lu.%9lu %s:%d ", _lvchar[lv], tm.tv_sec, tm.tv_nsec, file, lineno); if (likely(r < LOG_BUF_SZ)) { int n; va_list alist; va_start(alist, fmt); n = vsnprintf(buf + r, LOG_BUF_SZ - r, fmt, alist); va_end(alist); r += n; } if (unlikely(r > LOG_BUF_SZ)) r = LOG_BUF_SZ; fd = (likely(lv < YLOG_ERR))? _cfg.stdfd: _cfg.errfd; write_fd(fd, buf, r); /* return value is ignored intentionally */ }
void process_events(int count) { int idx, res; //printf("count of desc %d\n", count); for (idx = 1; idx < count; idx++) { if (poll_fd[idx].revents & (POLLIN|POLLPRI)) { res = read_fd(poll_fd[idx].fd, &peer_ctx[idx]); if (res == 0 && peer_ctx[idx].sfd != -1) write_fd(poll_fd[idx].fd, &peer_ctx[idx]); else if (res == 0 && peer_ctx[idx].sfd == -1) { close(poll_fd[idx].fd); poll_fd[idx].fd = -1; poll_fd[idx].events = 0; poll_fd[idx].revents = 0; continue; } else continue; printf("revents %d, Client send: %s\n", poll_fd[idx].revents, peer_ctx[idx].buf); } if (poll_fd[idx].revents & (POLLERR|POLLNVAL)) { printf("we recived %d event from %d desc\n", poll_fd[idx].revents, poll_fd[idx].fd); poll_fd[idx].fd = -1; poll_fd[idx].events = 0; poll_fd[idx].revents = 0; } } }
void io_service::process_sets(struct pollfd* fds, std::size_t nfds) { std::vector<int> fds_to_read; std::vector<int> fds_to_write; //! Quickly fetch fds that are readable/writeable //! This reduce lock time and avoid possible deadlock in callbacks { std::lock_guard<std::recursive_mutex> lock(m_fds_mutex); for (std::size_t i = 0; i < nfds; ++i) { if (fds[i].revents & POLLIN && m_fds[fds[i].fd].async_read) fds_to_read.push_back(fds[i].fd); if (fds[i].revents & POLLOUT && m_fds[fds[i].fd].async_write) fds_to_write.push_back(fds[i].fd); } } for (int fd : fds_to_read) { read_fd(fd); } for (int fd : fds_to_write) { write_fd(fd); } if (fds[0].revents & POLLIN) { char buf[1024]; (void) read(m_notif_pipe_fds[0], buf, 1024); } }
int main(void) { int sockfd[2]; socketpair(AF_LOCAL, SOCK_STREAM, 0, sockfd); int pid; int c = 0; int sd; int status; if ((pid = fork()) > 0) { close(sockfd[1]); read_fd(sockfd[0], &c, sizeof(int), &sd); fprintf(stderr, "read fd is : %d\n", sd); } close(sockfd[0]); int fd = open("/home/orion/codes/test/c/erm/erm_commnu_module.h",O_RDONLY); write_fd(sockfd[1], (void *)&c, sizeof(int), fd); fprintf(stderr, "write fd is : %d\n", fd); if (waitpid(pid, &status, 0) != 0 ) { perror("waitpid"); exit(1); } return 0; }
ssize_t Write_fd(int fd, void *ptr, size_t nbytes, int sendfd){ ssize_t n; if( (n = write_fd(fd, ptr, nbytes, sendfd)) < 0) err_sys("write_fd error"); return n; }
/* * Class: info_kghost_android_openvpn_ManagementSocket * Method: write * Signature: (ILjava/nio/ByteBuffer;IILinfo/kghost/android/openvpn/FileDescriptorHolder;)I */ JNIEXPORT jint JNICALL Java_info_kghost_android_openvpn_ManagementSocket_write__ILjava_nio_ByteBuffer_2IILinfo_kghost_android_openvpn_FileDescriptorHolder_2 (JNIEnv *env, jclass cls, jint socket, jobject buffer, jint offset, jint length, jobject fd) { if (socket < 0) { throwError(env, "java/lang/IllegalArgumentException", "socket"); return -1; } jlong cap = (*env)->GetDirectBufferCapacity(env, buffer); char* ptr = (*env)->GetDirectBufferAddress(env, buffer); int sendfd = jniGetFDFromFileDescriptor(env, fd); if (cap-offset < length) { throwError(env, "java/lang/IllegalArgumentException", "socket"); return -1; } int result = write_fd(socket, ptr+offset, length, sendfd); if (result < 0) { switch (errno) { case EACCES: case EBADF: case ENOTCONN: case ENOTSOCK: case EISCONN: case ECONNRESET: case EDESTADDRREQ: throwError(env, "java/lang/IllegalArgumentException", "socket"); break; case EINVAL: throwError(env, "java/lang/IllegalArgumentException", "inval"); break; case EFAULT: throwError(env, "java/lang/IllegalArgumentException", "buffer"); break; case EMSGSIZE: throwError(env, "java/lang/IllegalArgumentException", "msg size"); break; case EINTR: throwError(env, "java/lang/InterruptedException", "interrupted"); break; case ENOBUFS: case ENOMEM: throwError(env, "java/lang/RuntimeException", "oom"); break; case EAGAIN: throwError(env, "java/lang/IllegalArgumentException", "non-block socket"); break; default: throwError(env, "java/lang/RuntimeException", strerror(errno)); break; } } return result; }
int main(int argc, char **argv) { int fd; if(argc != 4) err_quit("OpenFile <sockfd#> <filename> <mode>"); if((fd=open(argv[2],atoi(arg[3]))) < 0) exit((errno > 0) ? errno : 255); if(write_fd(atoi(argv[1]), " ", 1, fd) < 0) exit((errno > 0) ? errno : 255); exit(0); }
ssize_t Write_fd(int fd, void *ptr, size_t nbytes, int sendfd) { ssize_t n; if ( (n = write_fd(fd, ptr, nbytes, sendfd)) < 0) //err_sys("write_fd error"); fprintf(stderr, "write_fd error"); return(n); }
static t_client *write_to_write(t_client *client) { client->to_write = first_node(&client->to_write->node); if (client->to_write == NULL) return (client); if (write_fd(client->to_write->str, client->ca.cfd) == true) return (sup_client(client)); free(client->to_write->str); client->to_write = sup_node(&client->to_write->node); return (client); }
int main(int argc, char **argv) { int fd; ssize_t n; if (argc != 4) perror("openfile <sockfd#> <filename> <mode>"); if ( (fd = open(argv[2], atoi(argv[3]))) < 0) exit( (errno > 0) ? errno : 255 ); if ( (n = write_fd(atoi(argv[1]), "", 1, fd)) < 0) exit( (errno > 0) ? errno : 255 ); exit(0); }
int myopen(char *path, int flag) { int sock_fd[2]; pid_t childpid; char *str_socket_fileno; char *str_open_flag; int fd; int wait_state; int state; if(socketpair(PF_LOCAL, SOCK_STREAM, 0, sock_fd) < 0 ) { perror(""); exit(1); } if ( (childpid = fork()) == 0 ) { close(sock_fd[0]); if( (fd = open(path, flag)) < 0 ) { perror(""); exit(1); } if ( write_fd(sock_fd[1], fd) < 0 ) { perror(""); exit(1); } exit(0); } close(sock_fd[1]); if ( waitpid(childpid, &state, 0) == -1 ) { perror(""); exit(1); } if ( ! WIFEXITED(state) || WEXITSTATUS(state) != 0 ) { printf("child exit failure"); exit(1); } fd = read_fd(sock_fd[0]); close(sock_fd[0]); return fd; }
static int _write_fd(ssize_t (*write_fd)(int fd, void *p, size_t count), int fd, void *p, size_t count) { ssize_t ret; size_t sent = 0; while (sent < count) { ret = write_fd(fd, ((uint8_t*)p)+sent, count-sent); if (ret < 0) { if (errno == EAGAIN || errno == EINTR) continue; else return -1; } sent += ret; } return 0; }
int main(int argc, char **argv){ int fd; ssize_t n; printf("enter openfile\n"); if(argc != 4){ perror("argc != 4"); exit(1); } if((fd = open(argv[2], atoi(argv[3]))) < 0){ perror("open"); exit(1); } printf("write fd fd = %d\n", fd); if((n = write_fd(atoi(argv[1]), "", 1, fd)) < 0){ perror("write fd error"); exit(1); } exit(0); }
void handler() { printf("Handler Called\n"); if(scnt<tcnt) { int i; for (i = 0; i < 3; ++i) { if(flag[i]==0) break; } if(i!=3) { flag[i]=1; char *buf=(char*)malloc(255); sprintf(buf,"%d",no[scnt]); send(queue[scnt],buf,strlen(buf),0); write_fd(nusfd[i],queue[scnt]); announce(i,no[scnt]); scnt++; } } }
void libwrap_auth(CLI *c, char *accepted_address) { int result=0; /* deny by default */ #ifdef USE_PTHREAD static volatile int num_busy=0, roundrobin=0; int retval, my_process; static pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER; static pthread_cond_t cond=PTHREAD_COND_INITIALIZER; #endif /* USE_PTHREAD */ if(!c->opt->option.libwrap) /* libwrap is disabled for this service */ return; /* allow connection */ #ifdef HAVE_STRUCT_SOCKADDR_UN if(c->peer_addr.sa.sa_family==AF_UNIX) { s_log(LOG_INFO, "Libwrap is not supported on Unix sockets"); return; } #endif #ifdef USE_PTHREAD if(num_processes) { s_log(LOG_DEBUG, "Waiting for a libwrap process"); retval=pthread_mutex_lock(&mutex); if(retval) { errno=retval; ioerror("pthread_mutex_lock"); longjmp(c->err, 1); } while(num_busy==num_processes) { /* all child processes are busy */ retval=pthread_cond_wait(&cond, &mutex); if(retval) { errno=retval; ioerror("pthread_cond_wait"); longjmp(c->err, 1); } } while(busy[roundrobin]) /* find a free child process */ roundrobin=(roundrobin+1)%num_processes; my_process=roundrobin; /* the process allocated by this thread */ ++num_busy; /* the child process has been allocated */ busy[my_process]=1; /* mark the child process as busy */ retval=pthread_mutex_unlock(&mutex); if(retval) { errno=retval; ioerror("pthread_mutex_unlock"); longjmp(c->err, 1); } s_log(LOG_DEBUG, "Acquired libwrap process #%d", my_process); write_fd(ipc_socket[2*my_process], c->opt->servname, strlen(c->opt->servname)+1, c->local_rfd.fd); read_blocking(c, ipc_socket[2*my_process], (u8 *)&result, sizeof result); s_log(LOG_DEBUG, "Releasing libwrap process #%d", my_process); retval=pthread_mutex_lock(&mutex); if(retval) { errno=retval; ioerror("pthread_mutex_lock"); longjmp(c->err, 1); } busy[my_process]=0; /* mark the child process as free */ --num_busy; /* the child process has been released */ if(num_busy==num_processes-1) { /* need to wake up a thread */ retval=pthread_cond_signal(&cond); /* signal waiting threads */ if(retval) { errno=retval; ioerror("pthread_cond_signal"); longjmp(c->err, 1); } } retval=pthread_mutex_unlock(&mutex); if(retval) { errno=retval; ioerror("pthread_mutex_unlock"); longjmp(c->err, 1); } s_log(LOG_DEBUG, "Released libwrap process #%d", my_process); } else #endif /* USE_PTHREAD */ { /* use original, synchronous libwrap calls */ enter_critical_section(CRIT_LIBWRAP); result=check(c->opt->servname, c->local_rfd.fd); leave_critical_section(CRIT_LIBWRAP); } if(!result) { s_log(LOG_WARNING, "Service [%s] REFUSED by libwrap from %s", c->opt->servname, accepted_address); s_log(LOG_DEBUG, "See hosts_access(5) manual for details"); longjmp(c->err, 1); } s_log(LOG_DEBUG, "Service [%s] permitted by libwrap from %s", c->opt->servname, accepted_address); }
int cwritefile(char *fname, int r0, int c0, int rn, int cn) { register FILE *f; int pipefd[2]; int fildes; int pid; char save[PATHLEN]; char *fn; char *busave; if (*fname == '\0') fname = &curfile[0]; fn = fname; while (*fn && (*fn == ' ')) /* Skip leading blanks */ fn++; if (*fn == '|') { error("Can't have encrypted pipe"); return (-1); } (void) strcpy(save, fname); busave = findhome(save); #ifdef DOBACKUPS if (!backup_file(busave) && (yn_ask("Could not create backup copy, Save anyway?: (y,n)") != 1)) return (0); #endif if ((fildes = open (busave, O_TRUNC|O_WRONLY|O_CREAT, 0600)) < 0) { error("Can't create file \"%s\"", save); return (-1); } if (pipe(pipefd) < 0) { error("Can't make pipe to child\n"); return (-1); } if (KeyWord[0] == '\0') { deraw(1); (void) strcpy(KeyWord, getpass("Enter key:")); goraw(); } if ((pid=fork()) == 0) { /* if child */ (void) close(0); /* close stdin */ (void) close(1); /* close stdout */ (void) close(pipefd[1]); /* close pipe output */ (void) dup(pipefd[0]); /* connect to pipe input */ (void) dup(fildes); /* standard out to file */ (void) fprintf(stderr, " "); (void) execl(CRYPT_PATH, "crypt", KeyWord, 0); (void) fprintf(stderr, "execl(%s, \"crypt\", %s, 0) in cwritefile() failed", CRYPT_PATH, KeyWord); exit (-127); } else { /* else parent */ (void) close(fildes); (void) close(pipefd[0]); /* close pipe input */ f = fdopen(pipefd[1], "w"); if (f == 0) { (void) kill(pid, -9); error("Can't fdopen file \"%s\"", save); (void) close(pipefd[1]); return (-1); } } write_fd(f, r0, c0, rn, cn); (void) fclose(f); (void) close(pipefd[1]); while (pid != wait(&fildes)) /**/; (void) strcpy(curfile,save); modflg = 0; error("File \"%s\" written (encrypted).", curfile); return (0); }
// Funcion que graba un archivo // recibe un rango como parametros y un nombre de archivo a generar int writefile(char * fname, int r0, int c0, int rn, int cn) { register FILE *f; char save[PATHLEN]; char tfname[PATHLEN]; long namelen; char *tpp; int pid; /* find the extension and mapped plugin if exists if ((p = strrchr(fname, '.'))) { if ((plugin = findplugin(p+1, 'w')) != NULL) { if (!plugin_exists(plugin, strlen(plugin), save + 1)) { error("plugin not found"); return -1; } *save = '|'; if ((strlen(save) + strlen(fname) + 20) > PATHLEN) { error("Path too long"); return -1; } sprintf(save + strlen(save), " %s%d:", coltoa(c0), r0); sprintf(save + strlen(save), "%s%d \"%s\"", coltoa(cn), rn, fname); // pass it to readfile as an advanced macro readfile(save, 0); return (0); } }*/ if (*fname == '\0') { if (isatty(STDOUT_FILENO) || *curfile != '\0') fname = curfile; else { write_fd(stdout, r0, c0, rn, cn); return 0; } } if ((tpp = strrchr(fname, '/')) == NULL) namelen = pathconf(".", _PC_NAME_MAX); else { *tpp = '\0'; namelen = pathconf(fname, _PC_NAME_MAX); *tpp = '/'; } (void) strcpy(tfname, fname); for (tpp = tfname; *tpp != '\0'; tpp++) if (*tpp == '\\' && *(tpp + 1) == '"') (void) memmove(tpp, tpp + 1, strlen(tpp)); if (scext != NULL) { if (strlen(tfname) > 3 && !strcmp(tfname + strlen(tfname) - 3, ".sc")) tfname[strlen(tfname) - 3] = '\0'; else if (strlen(tfname) > strlen(scext) + 1 && tfname[strlen(tfname) - strlen(scext) - 1] == '.' && ! strcmp(tfname + strlen(tfname) - strlen(scext), scext)) tfname[strlen(tfname) - strlen(scext) - 1] = '\0'; tfname[namelen - strlen(scext) - 1] = '\0'; strcat(tfname, "."); strcat(tfname, scext); } (void) strcpy(save, tfname); for (tpp = save; *tpp != '\0'; tpp++) if (*tpp == '"') { (void) memmove(tpp + 1, tpp, strlen(tpp) + 1); *tpp++ = '\\'; } if ((f = openfile(tfname, &pid, NULL)) == NULL) { error("Can't create file \"%s\"", save); return -1; } info("Writing file \"%s\"...", save); write_fd(f, r0, c0, rn, cn); closefile(f, pid, 0); if (!pid) { (void) strcpy(curfile, save); modflg = 0; info("File \"%s\" written", curfile); } return 0; }
void dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen) { int icmpfd, maxfdp1; char sendline[MAXLINE], recvline[MAXLINE + 1]; fd_set rset; ssize_t n; struct timeval tv; struct icmpd_err icmpd_err; struct sockaddr_un sun; if (sock_bind_wild(sockfd, pservaddr->sa_family) < 0) { perror("sock_bind_wild error"); exit(1); } if ((icmpfd = socket(AF_LOCAL, SOCK_STREAM, 0)) < 0) { perror("socket error"); exit(1); } sun.sun_family = AF_LOCAL; strcpy(sun.sun_path, ICMPD_PATH); if (connect(icmpfd, (SA *)&sun, sizeof(sun)) < 0) { perror("connect error"); exit(1); } if (write_fd(icmpfd, "1", 1, sockfd) < 0) { perror("write_fd error"); exit(1); } if ((n = read(icmpfd, recvline, 1)) == -1) { perror("read error"); exit(1); } if (n != 1 || recvline[0] != '1') { fprintf(stderr, "error creating icmp socket, n = %d, char = %c\n", n, recvline[0]); exit(1); } FD_ZERO(&rset); maxfdp1 = max(sockfd, icmpfd) + 1; /* end dgcli011 */ /* include dgcli012 */ while (fgets(sendline, MAXLINE, fp) != NULL) { n = strlen(sendline); if (sendto(sockfd, sendline, n, 0, pservaddr, servlen) != n) { perror("sendto error"); exit(1); } tv.tv_sec = 5; tv.tv_usec = 0; FD_SET(sockfd, &rset); FD_SET(icmpfd, &rset); if ( (n = select(maxfdp1, &rset, NULL, NULL, &tv)) < 0) { perror("select error"); exit(1); } else if (n == 0) { fprintf(stderr, "socket timeout\n"); continue; } if (FD_ISSET(sockfd, &rset)) { if ((n = recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL)) < 0) { perror("recvfrom error"); exit(1); } recvline[n] = 0; /* null terminate */ if (fputs(recvline, stdout) == EOF) { perror("fputs error"); exit(1); } } if (FD_ISSET(icmpfd, &rset)) { if ( (n = read(icmpfd, &icmpd_err, sizeof(icmpd_err))) < 0) { perror("read error"); exit(1); } else if (n == 0) { fprintf(stderr, "ICMP daemon terminated\n"); exit(1); } else if (n != sizeof(icmpd_err)) { fprintf(stderr, "n = %d, expected %d\n", n, sizeof(icmpd_err)); exit(1); } printf("ICMP error: dest = %s, %s, type = %d, code = %d\n", sock_ntop(&icmpd_err.icmpd_dest, icmpd_err.icmpd_len), strerror(icmpd_err.icmpd_errno), icmpd_err.icmpd_type, icmpd_err.icmpd_code); } } }
static int zsocket(zoneid_t zoneid, const char *path) { char c = 0; ctid_t ct = -1; int _errno = 0; int pid = 0; int sock_fd = 0; int sockfd[2] = {0}; int stat = 0; int tmpl_fd = 0; int flags; struct sockaddr_un addr; size_t addr_len = 0; if (zoneid < 0) { return (-1); } if (path == NULL) { return (-1); } bzero(&addr, sizeof (addr)); pthread_mutex_lock(&lock); if ((tmpl_fd = init_template()) < 0) { pthread_mutex_unlock(&lock); return (-1); } if (socketpair(AF_LOCAL, SOCK_STREAM, 0, sockfd) != 0) { (void) ct_tmpl_clear(tmpl_fd); pthread_mutex_unlock(&lock); return (-1); } pid = fork(); debug("fork returned: %d\n", pid); if (pid < 0) { _errno = errno; (void) ct_tmpl_clear(tmpl_fd); close(sockfd[0]); close(sockfd[1]); errno = _errno; pthread_mutex_unlock(&lock); return (-1); } if (pid == 0) { (void) ct_tmpl_clear(tmpl_fd); (void) close(tmpl_fd); (void) close(sockfd[0]); if (zone_enter(zoneid) != 0) { debug("CHILD: zone_enter(%d) => %s\n", zoneid, strerror(errno)); _exit(1); } debug("CHILD: zone_enter(%d) => %d\n", zoneid, 0); (void) unlink(path); sock_fd = socket(PF_UNIX, SOCK_STREAM, 0); if (sock_fd < 0) { debug("CHILD: socket => %d\n", errno); _exit(2); } fcntl(sock_fd, F_SETFL, O_NONBLOCK); addr.sun_family = AF_UNIX; addr_len = sizeof (addr.sun_family) + snprintf(addr.sun_path, sizeof (addr.sun_path), path); if (bind(sock_fd, (struct sockaddr *) &addr, addr_len) != 0) { debug("CHILD: bind => %d\n", errno); _exit(3); } if (write_fd(sockfd[1], (void *)"", 1, sock_fd) < 0) { debug("CHILD: write_fd => %d\n", errno); _exit(4); } debug("CHILD: write_fd => %d\n", errno); _exit(0); } if (contract_latest(&ct) == -1) { ct = -1; } (void) ct_tmpl_clear(tmpl_fd); (void) close(tmpl_fd); (void) contract_abandon_id(ct); (void) close(sockfd[1]); debug("PARENT: waitforpid(%d)\n", pid); while ((waitpid(pid, &stat, 0) != pid) && errno != ECHILD) { /* DO NOTHING */; } if (WIFEXITED(stat) == 0) { debug("PARENT: Child didn't exit\n"); _errno = ECHILD; sock_fd = -1; } else { stat = WEXITSTATUS(stat); debug("PARENT: Child exit status %d\n", stat); if (stat == 0) { read_fd(sockfd[0], &c, 1, &sock_fd); } else { _errno = stat; sock_fd = -1; } } close(sockfd[0]); pthread_mutex_unlock(&lock); if (sock_fd < 0) { errno = _errno; } else { if ((flags = fcntl(sock_fd, F_GETFD)) != -1) { flags |= FD_CLOEXEC; (void) fcntl(sock_fd, F_SETFD, flags); } errno = 0; } debug("zsocket returning fd=%d, errno=%d\n", sock_fd, errno); return (sock_fd); }
/** * new connecion comes, copy file descroptor of new connecton to child * process , parent process select * @return 0 */ int main(int argc, char **argv) { int res; res = register_sig_handler(); if (res < 0) err_sys("register_sig_handler is err"); my_getopt(argc, argv); int pipefd[2]; int socket_fd; res = srv_socket_init(&socket_fd, 50, PORT); if (res < 0) err_sys("srv_socket_init err"); fd_set myset; FD_ZERO(&myset); FD_SET(socket_fd, &myset); int max = socket_fd; arraychild = (child_t *) malloc(sizeof(child_t) * childnum); memset(arraychild, 0, sizeof(child_t) * childnum); for (int i = 0 ; i < childnum; i++) { res = socketpair(AF_LOCAL, SOCK_STREAM, 0, pipefd); if (res < 0) err_sys("socketpair is err"); arraychild[i].child_pipefd = pipefd[0]; FD_SET(pipefd[0], &myset); if (pipefd[0] > max) max = pipefd[0]; int pid = fork(); if (pid < 0) err_sys("fork err"); if (pid == 0) { srv_socket_destory(&socket_fd); int connfd; int childpid = getpid(); while(1) { char c; res = read_fd(pipefd[1], &c, 1, &connfd); if (res < 0) err_sys("read_fd err"); fprintf(stdout, "pid is %d, accept success.\n",childpid); child_process(connfd); write(pipefd[1], "", 1); srv_socket_close(&connfd); } //exit(0); } else { arraychild[i].child_pid = pid; } } struct sigaction myact; myact.sa_handler = sig_int_handler; if (sigaction(SIGINT, &myact, NULL) < 0) err_sys("sigaction err"); int navail = childnum; fd_set rset ; int newfd; int i = 0; while(1) { rset = myset; if (navail <=0 ) FD_CLR(socket_fd, &rset); select(max + 1, &rset, NULL, NULL, NULL); if (FD_ISSET(socket_fd, &rset)) { newfd = accept(socket_fd, NULL, NULL); for (i = 0; i < childnum; i++) { if (arraychild[i].child_status == 0) break; } res = write_fd(arraychild[i].child_pipefd, "", 1, newfd); if (res < 0) { continue; } srv_socket_close(&newfd); arraychild[i].child_status = 1; arraychild[i].child_count++; navail--; } for (int i = 0; i < childnum; i++) { char c; if (FD_ISSET(arraychild[i].child_pipefd, &rset)) { read(arraychild[i].child_pipefd, &c, 1); arraychild[i].child_status = 0; navail++; } } } return 0; }
int main(int argc, char *argv[]) { char **argp = ++argv; char *fname; char *op; int max_pages; int rest_secs; int iteration = 0; #define NARGS 4 if(argc < NARGS + 1) { printf("frw <fname> <op=r/w> <max_pages> <rest_secs>\n"); printf("op = r - read , w - random, s - fsync write\n"); return -2; } fname = *argp++; op = *argp++; sscanf(*argp++, "%d", &max_pages); sscanf(*argp++, "%d", &rest_secs); printf("fname = %s op=%s max_pages = %d rest_secs = %d\n", fname, op, max_pages, rest_secs); if(op[0] == 'r') { slam_fd = open(fname, O_RDWR); } else { slam_fd = open(fname, O_WRONLY| O_TRUNC); if(slam_fd < 0 ) slam_fd = creat(fname, 0666); } if(slam_fd < 0) { perror("open:"); return -2; } signal(SIGINT, sigterm_hdlr); signal(SIGTERM, sigterm_hdlr); while(1) { timeit(NULL); if(op[0] == 'r') { read_fd(slam_fd, max_pages, op[1]=='r'); timeit("read"); } else { write_fd(slam_fd, max_pages, op[1]=='r'); if(op[0] == 's') { fsync(slam_fd); timeit("write fsync"); } else { timeit("write"); } } printf("%d:iter=%d\n", getpid(), iteration++); sleep(rest_secs); } return 0; }
int main(int argc, char const *argv[]) { if (argc!=2) { printf("Pass the main server Port\n"); exit(1); } shm_init(); int usfd=init_UDSSER(); init_Raw_Socket(); int i; for(i=0;i<3;i++) { int c=fork(); if(c==0) { execl("p","p",NULL); } } accept_UDS(usfd,nusfd,3); int train_no=1; flag[3]=getpid(); int sfd=socket(AF_INET,SOCK_STREAM,0); if (sfd==-1) { printf("Socket Error : %d\n",errno); exit(1); } struct sockaddr_in saddr; memset(&saddr, 0, sizeof(struct sockaddr_in)); saddr.sin_family=AF_INET; saddr.sin_port=htons(atoi(argv[1])); saddr.sin_addr.s_addr=inet_addr("127.0.0.1"); int addr_len=sizeof(struct sockaddr_in); int ret=bind(sfd,(struct sockaddr*)&saddr,sizeof(saddr)); if (ret==-1) { printf("Bind Error : %d\n",errno); exit(1); } ret=listen(sfd,10); if (ret==-1) { printf("Listen Error : %d\n", errno); exit(1); } signal(SIGUSR1,handler); while(1) { struct timeval tv; tv.tv_sec = 1; tv.tv_usec = 0; fd_set tr; FD_ZERO(&tr); FD_SET(sfd,&tr); int res=select(sfd+1,&tr,NULL,NULL,&tv); if(res>0&&FD_ISSET(sfd,&tr)) { struct sockaddr_in caddr; memset(&caddr, 0, sizeof(struct sockaddr_in)); int caddr_len=sizeof(saddr); int nsfd=accept(sfd,(struct sockaddr*)&caddr,&caddr_len); if(nsfd==-1) { printf("Accept Error : %d\n", errno); exit(1); } int i; for (i = 0; i < 3; ++i) { if(flag[i]==0) break; } if(i!=3) { flag[i]=1; char *buf=(char*)malloc(255); sprintf(buf,"%d",train_no); send(nsfd,buf,strlen(buf),0); write_fd(nusfd[i],nsfd); announce(i,train_no); } else { queue[tcnt]=nsfd; no[tcnt]=train_no; tcnt++; printf("%d is waiting ...\n",train_no ); } train_no++; } } }