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);
}
}
