static int get_size_from_file(const char *filename, long long int *retsize) { uint8_t *buf = NULL; size_t bufsize = -1; int errno_value; int ret = -1; int fd = open(filename, O_RDONLY); if (fd < 0) goto err; read_fd(fd, &buf, &bufsize); if (!buf) goto err; *retsize = strtoll((char *)buf, NULL, 0); if ((*retsize == LLONG_MIN || *retsize == LLONG_MAX) && errno == ERANGE) *retsize = -1; else ret = 0; err: errno_value = errno; if (fd >= 0) close(fd); if (buf != NULL) free(buf); errno = errno_value; return ret; }
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; }
void write_in_fd(int master, t_struct *s) { s->read = 0; if ((ioctl(0, TCGETS, &s->ln)) != 0) perror("Error on write_in_fd : ioctl 1"); s->ln.c_lflag &= ~(ICANON | ISIG | ECHO); if ((ioctl(0, TCSETS, &s->ln)) != 0) perror("Error on write_in_fd : ioctl 2"); else if ((s->buff = malloc(4096 * sizeof(char))) == NULL) perror("Error on write_in_fd : Malloc Failled"); while (s->r != -1) { if ((ioctl(1, TIOCGWINSZ, &s->winp)) != 0) perror("Error on write_in_fd : ioctl 3"); else if ((ioctl(master, TIOCSWINSZ, &s->winp)) != 0) perror("Error on write_in_fd : ioctl 4"); FD_ZERO(&s->fdset); FD_SET(0, &s->fdset); FD_SET(master, &s->fdset); if (select(master + 1, &s->fdset, NULL, NULL, NULL) >= 0) if ((s->r = read_fd(&s->buff, &s->read, &s->fdset, master, s)) == 1) fwrite(s->buff, s->read, sizeof(char), create_file()); } free(s->buff); }
void check_file(char *new_name) { int fd; char *file; if ((fd = open(new_name, O_RDONLY)) == -1) { my_putstr(RED_BOLD); my_error("[ERROR] ", 0); my_putstr(INIT); my_error("file :", 0); my_error(new_name, 0); free(new_name); my_error(" not accessible.\n", 0); return; } file = read_fd(fd); close(fd); my_putstr(CYAN_BOLD); my_putstr("Compiling :"); my_putstr(INIT); my_putstr(new_name); my_putchar('\n'); my_parsing(file, new_name); free(new_name); }
char *fdgetline(int const fd) { static char buf[BUF_SIZE]; static size_t i = 0; static ssize_t max = 0; size_t n; size_t l; char *p; p = NULL; l = 0; while (read_fd(buf, &i, &max, fd) == true) { n = 0; while (i + n < (size_t)max && buf[i + n] != '\n') n++; if ((p = realloc(p, l + (n < (size_t)max ? n + 1 : n) + 1)) == NULL || memcpy(p + l, buf + i, (n < (size_t)max ? n + 1 : n)) == NULL) return (NULL); i += n < (size_t)max ? n + 1 : n; l += n < (size_t)max ? n + 1 : n; p[l] = '\0'; if (n < (size_t)max) return (p); } return (p); }
/* * 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]); }
int get_next_line(int const fd, char **line) { static t_fd *cur_fd = NULL; char buf[BUFF_SIZE + 1]; char *str; int len; int ret; ret = 0; if (fd < 0 || line == NULL) return (ERR); cur_fd = get_fd(cur_fd, fd); while (fd >= 0 && ((len = chk_eol(cur_fd->lne)) || (ret = read_fd(fd, buf)) > 0) && len <= 0) cur_fd->lne = free_join(cur_fd->lne, buf, 2); if (ret == ERR) return (ERR); if (len > 0) cur_fd->lne[len - 1] = '\0'; *line = ft_strdup(cur_fd->lne); str = cur_fd->lne; cur_fd->lne = ((len > 0) ? ft_strdup(cur_fd->lne + len) : ft_strdup("")); free(str); cur_fd = cur_fd->srt; return ((len || **line) ? 1 : 0); }
/* * 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 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 my_open(const char *pathname, int mode) { int fd, sockfd[2], status; pid_t childpid; char c, argsockfd[10], argmode[10]; Socketpair(AF_LOCAL, SOCK_STREAM, 0, sockfd); //child process if ((childpid = Fork()) == 0) { Close(sockfd[0]); snprintf(argsockfd, sizeof(argsockfd), "%d", sockfd[1]); /* what is in sockfd[1] */ snprintf(argmode, sizeof(argmode), "%d", mode); execl("./openfile", "openfile", argsockfd, pathname, argmode, (char *)NULL); err_sys("execl error"); } //parent process Close(sockfd[1]); Waitpid(childpid, &status, 0); if (WIFEXITED(status) == 0) err_quit("child did not terminate"); if ((status = WEXITSTATUS(status)) == 0) read_fd(sockfd[0], &c, 1, &fd); else { errno = status; fd = -1; } Close(sockfd[0]); return (fd); }
int get_next_line(const int fd, char **line) { static char *chr; int ret; char *backn_index; if (!chr && (chr = (char *)malloc(sizeof(char))) == NULL) return (-1); backn_index = ft_strchr(chr, '\n'); while (backn_index == NULL) { if ((ret = read_fd(fd, &chr)) == 0) { if ((backn_index = ft_strchr(chr, '\0')) == chr) return (0); } else if (ret < 0) return (-1); else backn_index = ft_strchr(chr, '\n'); } *line = ft_strsub(chr, 0, backn_index - chr); backn_index = ft_strdup(backn_index + 1); free(chr); chr = backn_index; return ((!*line) ? -1 : 1); }
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; } } }
ssize_t Read_fd(int fd, void *ptr, size_t nbytes, int *recvfd) { ssize_t n; if ( (n = read_fd(fd, ptr, nbytes, recvfd)) < 0) err_sys("read_fd error"); return(n); }
int main(int, char* argv[]) { MyString err; // dup FD 0 since well will later replace FD 0 with the job's stdin // int sock_fd = dup(0); if (sock_fd == -1) { err.sprintf("dup error on FD 0: %s", strerror(errno)); full_write(0, err.Value(), err.Length() + 1); exit(1); } // set up an Env object that we'll use for the job. we'll initialize // it with the environment that Condor sends us then merge on top of // that the environment that glexec prepared for us // Env env; char* env_buf = read_env(sock_fd); MyString merge_err; if (!env.MergeFromV2Raw(env_buf, &merge_err)) { err.sprintf("Env::MergeFromV2Raw error: %s", merge_err.Value()); full_write(sock_fd, err.Value(), err.Length() + 1); exit(1); } env.MergeFrom(environ); delete[] env_buf; // now receive an FD on our stdin (which is a UNIX domain socket) // that we'll use as the job's stdin // int job_fd = read_fd(sock_fd); if (dup2(job_fd, 0) == -1) { err.sprintf("dup2 to FD 0 error: %s", strerror(errno)); full_write(sock_fd, err.Value(), err.Length() + 1); exit(1); } close(job_fd); if (fcntl(sock_fd, F_SETFD, FD_CLOEXEC) == -1) { err.sprintf("fcntl error setting close-on-exec: %s", strerror(errno)); full_write(sock_fd, err.Value(), err.Length() + 1); exit(1); } // now we can exec the job. for arguments, we shift this wrappers // arguments by one. similarly, the job's executable path is taken // as our argv[1] // char** envp = env.getStringArray(); execve(argv[1], &argv[1], envp); err.sprintf("execve error: %s", strerror(errno)); full_write(sock_fd, err.Value(), err.Length() + 1); exit(1); }
int recv_fd(int fd) { char buf[2]; memset(buf,'\0',sizeof(buf)); int recvfd = -1; if(0 > read_fd(fd,buf,sizeof(buf),&recvfd)) { return -1; } return recvfd; }
int read_gnl(int ac, char **av) { int fd; int i; size_t ret; i = 0; if (ac == 1 && (int)(ret = read_fd(0)) < 0) return ((int)ret); while (++i < ac) { if ((fd = open(av[i], O_RDONLY)) < 0) return (-1); if ((ret = read_fd(fd)) < 0) return (ret); if (close(fd) < 0) return (-1); } return (ret); }
int check_fd(t_env *e) { if (FD_ISSET(e->fd.fd, &e->fd_read)) { return (read_fd(e)); } if (FD_ISSET(0, &e->fd_read)) { read_stdin(e); } return (1); }
int is_valid_header(int fd) { char *header; int result; header = read_fd(fd, 10); if (!header) return (ft_error_retint("Cannot read header of file\n", 1)); result = !ft_memcmp(header, "WOLF3D\0\0\0", 10); ft_memdel((void**)&header); return (result); }
/* * Class: info_kghost_android_openvpn_ManagementSocket * Method: read * Signature: (ILjava/nio/ByteBuffer;IILinfo/kghost/android/openvpn/FileDescriptorHolder;)I */ JNIEXPORT jint JNICALL Java_info_kghost_android_openvpn_ManagementSocket_read__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 recvfd = -1; if (cap-offset < length) { throwError(env, "java/lang/IllegalArgumentException", "socket"); return -1; } int result = read_fd(socket, ptr+offset, length, &recvfd); if (result < 0) { switch (errno) { case EBADF: case ENOTSOCK: case ENOTCONN: case ECONNREFUSED: 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 EINTR: throwError(env, "java/lang/InterruptedException", "interrupted"); break; 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; } if (recvfd >= 0) { jniSetFileDescriptorOfFD(env, fd, recvfd); } return result; }
int libwrap_init() { #ifdef USE_PTHREAD int i, j, rfd, result; char servname[SERVNAME_LEN]; static int initialized=0; SERVICE_OPTIONS *opt; if(initialized) /* during startup or previous configuration file reload */ return 0; for(opt=service_options.next; opt; opt=opt->next) if(opt->option.libwrap) /* libwrap is enabled for this service */ break; if(!opt) /* disabled for all sections or inetd mode (no sections) */ return 0; num_processes=LIBWRAP_CLIENTS; ipc_socket=str_alloc(2*num_processes*sizeof(int)); busy=str_alloc(num_processes*sizeof(int)); for(i=0; i<num_processes; ++i) { /* spawn a child */ if(s_socketpair(AF_UNIX, SOCK_STREAM, 0, ipc_socket+2*i, 0, "libwrap_init")) return 1; switch(fork()) { case -1: /* error */ ioerror("fork"); return 1; case 0: /* child */ drop_privileges(0); /* libwrap processes are not chrooted */ close(0); /* stdin */ close(1); /* stdout */ if(!global_options.option.foreground) /* for logging in read_fd */ close(2); /* stderr */ for(j=0; j<=i; ++j) /* close parent-side sockets created so far */ close(ipc_socket[2*j]); while(1) { /* main libwrap child loop */ if(read_fd(ipc_socket[2*i+1], servname, SERVNAME_LEN, &rfd)<=0) _exit(0); result=check(servname, rfd); write(ipc_socket[2*i+1], (u8 *)&result, sizeof result); if(rfd>=0) close(rfd); } default: /* parent */ close(ipc_socket[2*i+1]); /* child-side socket */ } } initialized=1; #endif /* USE_PTHREAD */ return 0; }
static int vars_get_variable(efi_guid_t guid, const char *name, uint8_t **data, size_t *data_size, uint32_t *attributes) { int errno_value; int ret = -1; uint8_t *buf = NULL; size_t bufsize = -1; char *path; int rc = asprintf(&path, VARS_PATH "%s-" GUID_FORMAT "/raw_var", name, guid.a, guid.b, guid.c, bswap_16(guid.d), guid.e[0], guid.e[1], guid.e[2], guid.e[3], guid.e[4], guid.e[5]); if (rc < 0) return -1; int fd = open(path, O_RDONLY); if (fd < 0) goto err; read_fd(fd, &buf, &bufsize); if (!buf) goto err; efi_variable_t *var = (void *)buf; *data = malloc(var->DataSize); if (!*data) goto err; memcpy(*data, var->Data, var->DataSize); *data_size = var->DataSize; *attributes = var->Attributes; ret = 0; err: errno_value = errno; if (buf) free(buf); if (fd >= 0) close(fd); if (path) free(path); errno = errno_value; return ret; }
/* * Class: info_kghost_android_openvpn_OpenVpn_ControlChannel * Method: recv * Signature: (Linfo/kghost/android/openvpn/FileDescriptorHolder;Ljava/nio/Buffer;IILinfo/kghost/android/openvpn/FileDescriptorHolder;)I */ JNIEXPORT jint JNICALL Java_info_kghost_android_openvpn_OpenVpn_00024ControlChannel_recv (JNIEnv *env, jclass cls, jobject socket, jobject buffer, jint offset, jint length, jobject fd) { int s = jniGetFDFromFileDescriptor(env, socket); if (s < 0) { throwError(env, "java/lang/IllegalArgumentException", "socket"); return -1; } jlong cap = (*env)->GetDirectBufferCapacity(env, buffer); char* ptr = (*env)->GetDirectBufferAddress(env, buffer); int recvfd = -1; int result = read_fd(s, ptr+offset, min(cap-offset, length), &recvfd); if (result < 0) { switch (errno) { case EBADF: case ENOTSOCK: case ENOTCONN: case ECONNREFUSED: 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 EINTR: throwError(env, "java/lang/InterruptedException", "interrupted"); break; 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", "unknown error"); break; } return result; } if (recvfd >= 0) { jniSetFileDescriptorOfFD(env, fd, recvfd); } return result; }
static void msg_loop_simple () { fd_set fds; memset (&fds, 0, sizeof (fds)); int nfds = max<int> (rfd, rwfd) + 1; aiomsg_t msg; for (;;) { FD_SET(rfd, &fds); FD_SET(rwfd, &fds); int n = select (nfds, &fds, NULL, NULL, NULL); if (n < 0) { warn ("select error: %m\n"); } else { if (read_fd (rfd, &fds, &msg)) { srv->getmsg (msg); } if (read_fd (rwfd, &fds, &msg)) { srv->getmsg (msg); } } } }
static int read_file(pam_handle_t *pamh, const char *file) { int fd; int retval; fd = open(file, O_RDONLY); if (fd == -1) { _pam_log(LOG_INFO, "cannot open file %s: %s", file, strerror(errno)); return PAM_SYSTEM_ERR; } retval = read_fd(pamh, file, fd); close(fd); return retval; }
static int vars_del_variable(efi_guid_t guid, const char *name) { int errno_value; int ret = -1; char *path; int rc = asprintf(&path, VARS_PATH "%s-" GUID_FORMAT "/raw_var", name, guid.a, guid.b, guid.c, bswap_16(guid.d), guid.e[0], guid.e[1], guid.e[2], guid.e[3], guid.e[4], guid.e[5]); if (rc < 0) return -1; uint8_t *buf = NULL; size_t buf_size = 0; int fd = open(path, O_RDONLY); if (fd < 0) goto err; rc = read_fd(fd, &buf, &buf_size); if (rc < 0 || buf_size != sizeof(efi_variable_t)) goto err; close(fd); fd = open(VARS_PATH "del_var", O_WRONLY); if (fd < 0) goto err; rc = write(fd, buf, buf_size); if (rc >= 0) ret = 0; err: errno_value = errno; if (buf) free(buf); if (fd >= 0) close(fd); if (path) free(path); errno = errno_value; return ret; }
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; }
int my_open(const char *pathname, int mode) { int status, sockfd[2], fd; pid_t childpid; char argsockfd[10], argmode[10], c; if(socketpair(AF_UNIX, SOCK_STREAM, 0, sockfd) < 0){ perror("socketpair"); exit(1); } if((childpid = fork()) < 0){ perror("fork"); exit(1); }else if(childpid == 0){ close(sockfd[0]); snprintf(argsockfd, sizeof(argsockfd), "%d", sockfd[1]); snprintf(argmode, sizeof(argmode), "%d", mode); execl("./openfile", "openfile", argsockfd, pathname, argmode, (char *)NULL); perror("execl error"); exit(1); } close(sockfd[1]); if(waitpid(childpid, &status, 0) < 0){ perror("waitpid"); exit(1); } if(WIFEXITED(status) == 0){ perror("child not normal end"); exit(1); } if(WEXITSTATUS(status) == 0){ if(read_fd(sockfd[0], &c, 1, &fd) < 0){ perror("read_fd error"); exit(1); } }else{ fd = -1; } return (fd); }
int builtin_execute(Environment &e, const std::vector<std::string> &tokens, const fdmask &fds) { // runs argv[1] in the current environment. unlike MPW, argv[1] must be a script. // special enhancement -- '-' means execute stdin. if (tokens.size() < 2) return 0; std::string filename = tokens[1]; if (filename == "-") { // since we're parsing stdin, don't let any children read it. [???] fdset new_fds; int fd = open("/dev/null", O_RDONLY); new_fds.set(0, fd); return read_fd(e, fds[0], new_fds | fds); } return read_file(e, filename, fds); }
void libwrap_init(int num) { #ifdef USE_PTHREAD int i, j, rfd, result; char servname[SERVNAME_LEN]; num_processes=num; if(!num_processes) /* no extra processes to spawn */ return; ipc_socket=str_alloc(2*num_processes*sizeof(int)); busy=str_alloc(num_processes*sizeof(int)); if(!ipc_socket || !busy) { s_log(LOG_ERR, "Memory allocation failed"); die(1); } for(i=0; i<num_processes; ++i) { /* spawn a child */ if(s_socketpair(AF_UNIX, SOCK_STREAM, 0, ipc_socket+2*i, 0, "libwrap_init")) die(1); switch(fork()) { case -1: /* error */ ioerror("fork"); die(1); case 0: /* child */ drop_privileges(); /* libwrap processes are not chrooted */ close(0); /* stdin */ close(1); /* stdout */ if(!global_options.option.foreground) /* for logging in read_fd */ close(2); /* stderr */ for(j=0; j<=i; ++j) /* close parent-side sockets created so far */ close(ipc_socket[2*j]); while(1) { /* main libwrap child loop */ if(read_fd(ipc_socket[2*i+1], servname, SERVNAME_LEN, &rfd)<=0) _exit(0); result=check(servname, rfd); write(ipc_socket[2*i+1], (u8 *)&result, sizeof result); if(rfd>=0) close(rfd); } default: /* parent */ close(ipc_socket[2*i+1]); /* child-side socket */ } } #endif /* USE_PTHREAD */ }
void main(void) { struct addrinfo hints, *res; int sockfd; int backlog; int error; backlog = 3; memset(&hints, 0, sizeof hints); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; hints.ai_flags = AI_PASSIVE; getaddrinfo("127.0.0.1", "3490", &hints, &res); sockfd = socket(res->ai_family, res->ai_socktype, res->ai_protocol); bind(sockfd, res->ai_addr, res->ai_addrlen); error = listen(sockfd, 3); while (1) { read_fd(sockfd); } }