static void readFromPipe (evutil_socket_t fd, short eventType, void * veh) { char ch; int ret; tr_event_handle * eh = veh; dbgmsg ("readFromPipe: eventType is %hd", eventType); /* read the command type */ ch = '\0'; do { ret = piperead (fd, &ch, 1); } while (!eh->die && ret < 0 && errno == EAGAIN); dbgmsg ("command is [%c], ret is %d, errno is %d", ch, ret, (int)errno); switch (ch) { case 'r': /* run in libevent thread */ { struct tr_run_data data; const size_t nwant = sizeof (data); const ev_ssize_t ngot = piperead (fd, &data, nwant); if (!eh->die && (ngot == (ev_ssize_t) nwant)) { dbgmsg ("invoking function in libevent thread"); (data.func)(data.user_data); } break; } case '\0': /* eof */ { dbgmsg ("pipe eof reached... removing event listener"); event_free (eh->pipeEvent); tr_netCloseSocket (eh->fds[0]); event_base_loopexit (eh->base, NULL); break; } default: { assert (0 && "unhandled command type!"); break; } } }
void print_msg(int flag) { set_signal(SIGCHAT, print_msg); char buf[USER_NAME_MAX_LENGTH + 10], private; if (flag) { char buf2[STR_BUF_SIZE]; piperead(Pdesc2[1], Pdesc[0], &private, sizeof(char)); piperead(Pdesc2[1], Pdesc[0], buf, USER_NAME_MAX_LENGTH + 10); piperead(Pdesc2[1], Pdesc[0], buf2, STR_BUF_SIZE); if (private == PRIVATE) wattron(chatbox, A_BOLD); writestr(buf); writestr(buf2); wattroff(chatbox, A_BOLD); } else {
// Read from file f. int fileread(struct file *f, char *addr, int n) { int r; if (f->readable == 0) { return -1; } if (f->type == FD_PIPE) { return piperead(f->pipe, addr, n); } if (f->type == FD_INODE) { ilock(f->ip); if ((r = readi(f->ip, addr, f->off, n)) > 0) { f->off += r; } iunlock(f->ip); return r; } panic("fileread"); }
/* * read err msg from err pipe */ static void read_err_msg(int fid, StringInfo sinfo) { char ebuf[512]; int ebuflen = 512; while (true) { int nread = piperead(fid, ebuf, ebuflen); if(nread == 0) { break; } else if(nread > 0) { appendBinaryStringInfo(sinfo, ebuf, nread); } else { appendStringInfoString(sinfo, "error string unavailable due to read error"); break; } } if (sinfo->len > 0){ write_log("read err msg from pipe, len:%d msg:%s", sinfo->len, sinfo->data); } }
size_t url_execute_fread(void *ptr, size_t size, URL_FILE *file, CopyState pstate) { URL_EXECUTE_FILE *efile = (URL_EXECUTE_FILE *) file; return piperead(efile->handle->pipes[EXEC_DATA_P], ptr, size); }
int wait_until_received(const int mtype) { if (mtype > 0 && mtype <= MSG_TYPES_NUMBER) { if (pipewrite(Pdesc2[1], Pdesc[0], &mtype, sizeof(int)) == FAIL) return FAIL; if (mtype == RESPONSE) { if (piperead(Pdesc2[1], Pdesc[0], &response_data.response_type, sizeof(int)) == FAIL || piperead(Pdesc2[1], Pdesc[0], response_data.content, RESPONSE_LENGTH) == FAIL) { return FAIL; } } else if (mtype == USERS || mtype == ROOMS || mtype == ROOM_USERS_LIST) { int j = 0; while (piperead(Pdesc2[1], Pdesc[0], request_response_data->content[j], USER_NAME_MAX_LENGTH) > FAIL) ++j; if (j < MAX_SERVERS_NUMBER * MAX_USERS_NUMBER) request_response_data->content[j][0] = '\0'; } return 0; } return FAIL; }
int yuv_read_frame (int fd, unsigned char *yuv[3], int width, int height) { int v, h, i; unsigned char magic[7]; if (piperead (fd, magic, 6) != 6) return 0; if (strncmp (magic, "FRAME\n", 6)) { magic[6] = '\0'; printf("Error (yuv4mpeg.c): \nStart of frame is not \"FRAME\\n\"\n"); return 0; /* should we return -1 and set errno = EBADMSG instead? */ } h = width; v = height; /* Read luminance scanlines */ for (i = 0; i < v; i++) if (piperead (fd, yuv[0] + i * h, h) != h) return 0; v /= 2; h /= 2; /* Read chrominance scanlines */ for (i = 0; i < v; i++) if (piperead (fd, yuv[1] + i * h, h) != h) return 0; for (i = 0; i < v; i++) if (piperead (fd, yuv[2] + i * h, h) != h) return 0; return 1; }
int readPipe(int fd, void *buff, int buffsize) { int s = 0; int res = 0; retry: res = piperead(fd, (char *)buff + s, buffsize - s); if ( res > 0 ) { s += res; if ( buffsize - s > 0 ) { goto retry; } return s; } else if ( res == 0 ) { return s; } else if ( res == -1 && (errno == EAGAIN || errno == EINTR)) { goto retry; } write_log("readPipe got read() error , fd %d, (errno %d)", fd, errno); return -1; }
bool url_execute_ferror(URL_FILE *file, int bytesread, char *ebuf, int ebuflen) { URL_EXECUTE_FILE *efile = (URL_EXECUTE_FILE *) file; int ret; int nread; ret = (bytesread == -1); if(ret == true && ebuflen > 0 && ebuf != NULL) { /* * Read one byte less than the maximum size to ensure zero * termination of the buffer. */ nread = piperead(efile->handle->pipes[EXEC_ERR_P], ebuf, ebuflen -1); if(nread != -1) ebuf[nread] = 0; else strncpy(ebuf,"error string unavailable due to read error",ebuflen-1); } return ret; }
/* * Called in the background process whenever a complete segment of WAL * has been received. * On Unix, we check to see if there is any data on our pipe * (which would mean we have a stop position), and if it is, check if * it is time to stop. * On Windows, we are in a single process, so we can just check if it's * time to stop. */ static bool segment_callback(XLogRecPtr segendpos, uint32 timeline) { if (!has_xlogendptr) { #ifndef WIN32 fd_set fds; struct timeval tv; int r; /* * Don't have the end pointer yet - check our pipe to see if it has * been sent yet. */ FD_ZERO(&fds); FD_SET(bgpipe[0], &fds); MemSet(&tv, 0, sizeof(tv)); r = select(bgpipe[0] + 1, &fds, NULL, NULL, &tv); if (r == 1) { char xlogend[64]; MemSet(xlogend, 0, sizeof(xlogend)); r = piperead(bgpipe[0], xlogend, sizeof(xlogend)); if (r < 0) { fprintf(stderr, _("%s: could not read from ready pipe: %s\n"), progname, strerror(errno)); exit(1); } if (sscanf(xlogend, "%X/%X", &xlogendptr.xlogid, &xlogendptr.xrecoff) != 2) { fprintf(stderr, _("%s: could not parse xlog end position \"%s\"\n"), progname, xlogend); exit(1); } has_xlogendptr = 1; /* * Fall through to check if we've reached the point further * already. */ } else { /* * No data received on the pipe means we don't know the end * position yet - so just say it's not time to stop yet. */ return false; } #else /* * On win32, has_xlogendptr is set by the main thread, so if it's not * set here, we just go back and wait until it shows up. */ return false; #endif } /* * At this point we have an end pointer, so compare it to the current * position to figure out if it's time to stop. */ if (segendpos.xlogid > xlogendptr.xlogid || (segendpos.xlogid == xlogendptr.xlogid && segendpos.xrecoff >= xlogendptr.xrecoff)) return true; /* * Have end pointer, but haven't reached it yet - so tell the caller to * keep streaming. */ return false; }
/* * Main entry point for syslogger process * argc/argv parameters are valid only in EXEC_BACKEND case. */ __noexec_static__ void syslog_main(int argc, char *argv[]) { #ifndef WIN32 char logbuffer[READ_BUF_SIZE]; int bytes_in_logbuffer = 0; #endif char *current_log_dir; char *current_log_fname; int current_log_rotation_age; child = true;/* we are a postmaster subprocess now */ current_pid = getpid(); /* reset current_pid */ proc_start_time = time(NULL);/* set our start time in case we call elog */ #ifdef EXEC_BACKEND syslogger_parse_args(argc, argv); #endif /* EXEC_BACKEND */ am_syslogger = true; init_ps_display("logger process", "", "", ""); /* * If we restarted, our stderr is already redirected into our own input * pipe. This is of course pretty useless, not to mention that it * interferes with detecting pipe EOF. Point stderr to /dev/null. This * assumes that all interesting messages generated in the syslogger will * come through elog.c and will be sent to write_syslogger. */ if (redirection_done) { int fd = open(DEVNULL, O_WRONLY, 0); /* * The closes might look redundant, but they are not. We want * to be sure the pipe gets closed even if the open failed. * We can survive running with stderr pointing nowhere, but we * can't afford to have extra pipe input descriptors hanging i * around. */ close(fileno(stdout)); close(fileno(stderr)); if (fd != -1) { dup2(fd, fileno(stdout)); dup2(fd, fileno(stderr)); close(fd); } } /* * Syslogger's own stderr can't be the syslog_pipe, so set it back to i * text mode if we didn't just close it. It was set to binary in * submaster_main. */ #ifdef WIN32 else { _setmode(_fileno(stderr), _O_TEXT); } #endif /* * Also close our copy of the write end of the pipe. This is needed to * ensure we can detect pipe EOF correctly. But note that in the restart * case, the postmaster already did this. */ #ifndef WIN32 if (syslog_pipe[1] >= 0) close(syslog_pipe[1]); syslog_pipe[1] = -1; #else if (syslog_pipe[1]) CloseHandle(syslog_pipe[1]); syslog_pipe[1] = 0; #endif /* * If possible, make this process a group leader, so that the postmaster * can signal any child processes too. Syslogger probably never has any * child processes, but for consistency we make all postmaster child * processes do this. */ #ifdef HAVE_SETSID if (setsid() < 0) elog(FATAL, "setsid() failed: %m"); #endif /* * Properly accept or ignore signals the postmaster might send us * We ignore all termination signals, and instead exit only when all * upstream processes are gone, to ensure we don't miss any dying gaspsi * of broken backends... */ pqsignal(SIGHUP, syslog_sighup_handler); /* set flag to read conf file */ pqsignal(SIGINT, SIG_IGN); pqsignal(SIGTERM, SIG_IGN); pqsignal(SIGQUIT, SIG_IGN); pqsignal(SIGALRM, SIG_IGN); pqsignal(SIGPIPE, SIG_IGN); pqsignal(SIGUSR1, syslog_sigusr1_handler); /* request log rotation */ pqsignal(SIGUSR2, SIG_IGN); /* * Reset some signals that are accepted by postmaster but not here */ pqsignal(SIGCHLD, SIG_DFL); pqsignal(SIGTTIN, SIG_DFL); pqsignal(SIGTTOU, SIG_DFL); pqsignal(SIGCONT, SIG_DFL); pqsignal(SIGWINCH, SIG_DFL); SIGSET_MASK(&unblock_signal); #ifdef WIN32 /* Fire up separate data transfer thread */ InitializeCriticalSection(&sysloggerSection); EnterCriticalSection(&sysloggerSection); threadHandle = (HANDLE) _beginthreadex(NULL, 0, pipeThread, NULL, 0, NULL); if (threadHandle == 0) elog(FATAL, "could not create syslogger thread: %m"); #endif /* WIN32 */ /* * Remember active logfile parameters */ current_log_dir = pstrdup(log_directory); current_log_fname = pstrdup(log_filename); current_log_rotation_age = log_rotation_age; /* * Set next planned rotation time */ set_next_rotation_time(); /* * Main worker loop */ for (;;) { bool time_based_rotation = false; int size_rotation_for = 0; #ifndef WIN32 int bytesRead; int rc; fd_set rfds; struct timeval timeout; #endif if (got_sighup) { got_sighup = false; process_config_file(PGC_SIGHUP); /* * Check if the log directory or filename pattern * changed in postgresql.conf. If so, force rotation to * make sure we're writing the logfiles in the right * place. */ if (strcmp(log_directory, current_log_dir) != 0) { pfree(current_log_dir); current_log_dir = pstrdup(log_directory); rotation_requested = true; } if (strcmp(log_filename, current_log_fname) != 0) { pfree(current_log_fname); current_log_fname = pstrdup(log_filename); rotation_requested = true; } /* * If rotation time parameter changed, reset next * rotation time, but don't immediately force aa * rotation. */ if (current_log_rotation_age != log_rotation_age) { current_log_rotation_age = log_rotation_age; set_next_rotation_time(); } } if (!rotation_requested && log_rotation_age > 0) { /* Do a logfile rotation if it's time */ pg_time_t now = (pg_time_t) time(NULL); if (now >= next_rotation_time) rotation_requested = time_based_rotation = true; } if (!rotation_requested && log_rotation_size > 0) { /* * Do a rotation if file is too big */ if (ftell(syslog_file) >= log_rotation_size * 1024L) { rotation_requested = true; size_rotation_for |= DEST_STDERR; } if (cvs_logfile != NULL && ftell(cvs_logfile) >= log_rotation_size * 1024L) { rotation_requested = true; size_rotation_for |= DEST_CSVLOG; } } if (rotation_requested) { /* * Force rotation when both values are zero. It means * the request was sent by pg_rotate_logfile. */ if (!time_based_rotation && size_rotation_for == 0) size_rotation_for = DEST_STDERR | DEST_CSVLOG; logfile_rotate(time_based_rotation, size_rotation_for); } #ifndef WIN32 /* * Wait for some data, timing out after 1 second */ FD_ZERO(&rfds); FD_SET(syslog_pipe[0], &rfds); timeout.tv_sec = 1; timeout.tv_usec = 0; rc = select(syslog_pipe[0] + 1, &rfds, NULL, NULL, &timeout); if (rc < 0) { if (errno != EINTR) { ereport(LOG, ( errcode_sock_access(), errmsg("select() failed in logger process: %m"))); } } else if (rc > 0 && FD_ISSET(syslog_pipe[0], &rfds)) { bytesRead = piperead( syslog_pipe[0], logbuffer + bytes_in_logbuffer, sizeof(logbuffer) - bytes_in_logbuffer); if (bytesRead < 0) { if (errno != EINTR) ereport(LOG, (errcode_sock_access(), errmsg("could not read from logger pipe: %m"))); } else if (bytesRead > 0) { bytes_in_logbuffer += bytesRead; process_pipe_input(logbuffer, &bytes_in_logbuffer); continue; } else { /* * Zero bytes read when select() is saying * read-ready means EOF on the pipe. That is, * there are no longer any processes with the * pipe write end open. Therefore, the PM and * all backends are shut down, and we are done. */ pipe_eof_seen = true; /* * If there's any data left then force it out * now */ flush_pipe_input(logbuffer, &bytes_in_logbuffer); } } #else /* WIN32 */ /* * On Windows we leave it to a separate thread to transfer data * and detect pipe EOF. The main thread just wakes up once a * second to check for SIGHUP and rotation conditions. * * Server code isn't generally thread-safe, so we ensure that * only one of the threads is active at a time by entering the * critical section whenever we're not sleeping. */ LeaveCriticalSection(&sysloggerSection); pg_usleep(1000000L); EnterCriticalSection(&sysloggerSection); #endif /* WIN32 */ if (pipe_eof_seen) { /* * Seeing this message on the real stderr is annoying. * So we make it DEBUG1 to suppress in normal use. */ ereport(DEBUG1, (errmsg("logger shutting down"))); /* * Normal exit from the syslogger is here. Note that we * deliberately do not close syslog_file before exiting. * This is to allow for the possibility of elog * messages being generated inside proc_exit. Regular * exit() will take care of flushing and closing stdio * channels. */ proc_exit(0); } } }
static void readFromPipe( int fd, short eventType, void * veh ) { char ch; int ret; tr_event_handle * eh = veh; dbgmsg( "readFromPipe: eventType is %hd", eventType ); /* read the command type */ ch = '\0'; do { ret = piperead( fd, &ch, 1 ); } while( !eh->die && ret < 0 && errno == EAGAIN ); dbgmsg( "command is [%c], ret is %d, errno is %d", ch, ret, (int)errno ); switch( ch ) { case 'r': /* run in libevent thread */ { struct tr_run_data data; const size_t nwant = sizeof( data ); const ssize_t ngot = piperead( fd, &data, nwant ); if( !eh->die && ( ngot == (ssize_t)nwant ) ) { dbgmsg( "invoking function in libevent thread" ); ( data.func )( data.user_data ); } break; } case 't': /* create timer */ { tr_timer * timer; const size_t nwant = sizeof( timer ); const ssize_t ngot = piperead( fd, &timer, nwant ); if( !eh->die && ( ngot == (ssize_t)nwant ) ) { dbgmsg( "adding timer in libevent thread" ); evtimer_add( &timer->event, &timer->tv ); } break; } case '\0': /* eof */ { dbgmsg( "pipe eof reached... removing event listener" ); event_del( &eh->pipeEvent ); break; } default: { assert( 0 && "unhandled command type!" ); break; } } }
static gboolean client_thread_loop (BlockTxClient *client) { BlockTxInfo *info = client->info; fd_set fds; int max_fd = MAX (info->cmd_pipe[0], client->data_fd); int rc; gboolean restart = FALSE; struct timeval tmo; while (1) { FD_ZERO (&fds); FD_SET (info->cmd_pipe[0], &fds); /* Stop receiving any data after the client was shutdown. */ if (client->recv_state != RECV_STATE_DONE) { FD_SET (client->data_fd, &fds); max_fd = MAX (info->cmd_pipe[0], client->data_fd); } else max_fd = info->cmd_pipe[0]; /* If the client is already shutdown, no need to add timeout. */ if (client->recv_state != RECV_STATE_DONE) { tmo.tv_sec = RECV_TIMEOUT_SEC; tmo.tv_usec = 0; rc = select (max_fd + 1, &fds, NULL, NULL, &tmo); } else { rc = select (max_fd + 1, &fds, NULL, NULL, NULL); } if (rc < 0 && errno == EINTR) { continue; } else if (rc < 0) { seaf_warning ("select error: %s.\n", strerror(errno)); client->info->result = BLOCK_CLIENT_FAILED; break; } else if (rc == 0) { /* timeout */ if (info->task->type == TASK_TYPE_DOWNLOAD) { seaf_warning ("Recv timeout.\n"); client->info->result = BLOCK_CLIENT_NET_ERROR; if (do_break_loop (client)) break; } continue; } if (client->recv_state != RECV_STATE_DONE && FD_ISSET (client->data_fd, &fds)) { recv_data_cb (client); if (client->break_loop && do_break_loop (client)) break; } if (FD_ISSET (info->cmd_pipe[0], &fds)) { int cmd; piperead (info->cmd_pipe[0], &cmd, sizeof(int)); if (cmd == BLOCK_CLIENT_CMD_RESTART) { restart = TRUE; break; } if (handle_command (client, cmd)) break; } } return restart; }
/* * Main entry point for syslogger process * argc/argv parameters are valid only in EXEC_BACKEND case. */ NON_EXEC_STATIC void SysLoggerMain(int argc, char *argv[]) { char *currentLogDir; char *currentLogFilename; int currentLogRotationAge; IsUnderPostmaster = true; /* we are a postmaster subprocess now */ MyProcPid = getpid(); /* reset MyProcPid */ /* Lose the postmaster's on-exit routines */ on_exit_reset(); #ifdef EXEC_BACKEND syslogger_parseArgs(argc, argv); #endif /* EXEC_BACKEND */ am_syslogger = true; init_ps_display("logger process", "", ""); set_ps_display(""); /* * If we restarted, our stderr is already redirected into our own * input pipe. This is of course pretty useless, not to mention that * it interferes with detecting pipe EOF. Point stderr to /dev/null. * This assumes that all interesting messages generated in the * syslogger will come through elog.c and will be sent to * write_syslogger_file. */ if (redirection_done) { int fd = open(NULL_DEV, O_WRONLY); /* * The closes might look redundant, but they are not: we want to * be darn sure the pipe gets closed even if the open failed. We * can survive running with stderr pointing nowhere, but we can't * afford to have extra pipe input descriptors hanging around. */ close(fileno(stdout)); close(fileno(stderr)); dup2(fd, fileno(stdout)); dup2(fd, fileno(stderr)); close(fd); } /* * Also close our copy of the write end of the pipe. This is needed * to ensure we can detect pipe EOF correctly. (But note that in the * restart case, the postmaster already did this.) */ #ifndef WIN32 if (syslogPipe[1] >= 0) close(syslogPipe[1]); syslogPipe[1] = -1; #else if (syslogPipe[1]) CloseHandle(syslogPipe[1]); syslogPipe[1] = 0; #endif /* * Properly accept or ignore signals the postmaster might send us * * Note: we ignore all termination signals, and instead exit only when * all upstream processes are gone, to ensure we don't miss any dying * gasps of broken backends... */ pqsignal(SIGHUP, sigHupHandler); /* set flag to read config file */ pqsignal(SIGINT, SIG_IGN); pqsignal(SIGTERM, SIG_IGN); pqsignal(SIGQUIT, SIG_IGN); pqsignal(SIGALRM, SIG_IGN); pqsignal(SIGPIPE, SIG_IGN); pqsignal(SIGUSR1, SIG_IGN); pqsignal(SIGUSR2, SIG_IGN); /* * Reset some signals that are accepted by postmaster but not here */ pqsignal(SIGCHLD, SIG_DFL); pqsignal(SIGTTIN, SIG_DFL); pqsignal(SIGTTOU, SIG_DFL); pqsignal(SIGCONT, SIG_DFL); pqsignal(SIGWINCH, SIG_DFL); PG_SETMASK(&UnBlockSig); #ifdef WIN32 /* Fire up separate data transfer thread */ InitializeCriticalSection(&sysfileSection); { unsigned int tid; threadHandle = (HANDLE) _beginthreadex(0, 0, pipeThread, 0, 0, &tid); } #endif /* WIN32 */ /* remember active logfile parameters */ currentLogDir = pstrdup(Log_directory); currentLogFilename = pstrdup(Log_filename); currentLogRotationAge = Log_RotationAge; /* set next planned rotation time */ set_next_rotation_time(); /* main worker loop */ for (;;) { bool rotation_requested = false; bool time_based_rotation = false; #ifndef WIN32 char logbuffer[1024]; int bytesRead; int rc; fd_set rfds; struct timeval timeout; #endif if (got_SIGHUP) { got_SIGHUP = false; ProcessConfigFile(PGC_SIGHUP); /* * Check if the log directory or filename pattern changed in * postgresql.conf. If so, force rotation to make sure we're * writing the logfiles in the right place. */ if (strcmp(Log_directory, currentLogDir) != 0) { pfree(currentLogDir); currentLogDir = pstrdup(Log_directory); rotation_requested = true; } if (strcmp(Log_filename, currentLogFilename) != 0) { pfree(currentLogFilename); currentLogFilename = pstrdup(Log_filename); rotation_requested = true; } /* * If rotation time parameter changed, reset next rotation time, * but don't immediately force a rotation. */ if (currentLogRotationAge != Log_RotationAge) { currentLogRotationAge = Log_RotationAge; set_next_rotation_time(); } } if (!rotation_requested && Log_RotationAge > 0) { /* Do a logfile rotation if it's time */ pg_time_t now = time(NULL); if (now >= next_rotation_time) rotation_requested = time_based_rotation = true; } if (!rotation_requested && Log_RotationSize > 0) { /* Do a rotation if file is too big */ if (ftell(syslogFile) >= Log_RotationSize * 1024L) rotation_requested = true; } if (rotation_requested) logfile_rotate(time_based_rotation); #ifndef WIN32 /* * Wait for some data, timing out after 1 second */ FD_ZERO(&rfds); FD_SET(syslogPipe[0], &rfds); timeout.tv_sec = 1; timeout.tv_usec = 0; rc = select(syslogPipe[0] + 1, &rfds, NULL, NULL, &timeout); if (rc < 0) { if (errno != EINTR) ereport(LOG, (errcode_for_socket_access(), errmsg("select() failed in logger process: %m"))); } else if (rc > 0 && FD_ISSET(syslogPipe[0], &rfds)) { bytesRead = piperead(syslogPipe[0], logbuffer, sizeof(logbuffer)); if (bytesRead < 0) { if (errno != EINTR) ereport(LOG, (errcode_for_socket_access(), errmsg("could not read from logger pipe: %m"))); } else if (bytesRead > 0) { write_syslogger_file_binary(logbuffer, bytesRead); continue; } else { /* * Zero bytes read when select() is saying read-ready * means EOF on the pipe: that is, there are no longer any * processes with the pipe write end open. Therefore, the * postmaster and all backends are shut down, and we are * done. */ pipe_eof_seen = true; } } #else /* WIN32 */ /* * On Windows we leave it to a separate thread to transfer data * and detect pipe EOF. The main thread just wakes up once a * second to check for SIGHUP and rotation conditions. */ pgwin32_backend_usleep(1000000); #endif /* WIN32 */ if (pipe_eof_seen) { ereport(LOG, (errmsg("logger shutting down"))); /* * Normal exit from the syslogger is here. Note that we * deliberately do not close syslogFile before exiting; this * is to allow for the possibility of elog messages being * generated inside proc_exit. Regular exit() will take care * of flushing and closing stdio channels. */ proc_exit(0); } } }
static FILE *zpipe(Rng *r, int depth) { Pipe p = {}; switch(depth){ case 0: pipeadd(&p, "lvlgen", "25 25 3 -s %lu ", (unsigned long) rngint(r)); pipeadd(&p, "itmgen", "-s %lu %d 1", (unsigned long) rngint(r), ItemStatup); pipeadd(&p, "itmgen", "-s %lu %d %d %d %d %d %d %d %d 50", (unsigned long) rngint(r), ItemCopper, ItemCopper, ItemCopper, ItemCopper, ItemCopper, ItemSilver, ItemSilver, ItemGold ); pipeadd(&p, "itmgen", "-s %lu %d %d %d %d %d 5", (unsigned long) rngint(r), ItemHealth, ItemHealth, ItemHealth, ItemHealth, ItemCarrot ); pipeadd(&p, "itmgen", "-s %lu %d %d %d 1", (unsigned long) rngint(r), ItemBubble, ItemZap, ItemLead ); pipeadd(&p, "itmgen", "-s %lu %d 1", (unsigned long) rngint(r), ItemHamCan); pipeadd(&p, "envgen", "-s %lu %d 1", (unsigned long) rngint(r), EnvShrempty); pipeadd(&p, "envgen", "-s %lu %d %d %d 2", (unsigned long) rngint(r), EnvSwdStoneHp, EnvSwdStoneDex, EnvSwdStoneStr); pipeadd(&p, "envgen", "-s %lu %d %d %d %d 2", (unsigned long)rngint(r), EnvHelm0, EnvBody0, EnvGlove0, EnvBoot0); pipeadd(&p, "enmgen", "-s %lu %d %d %d %d %d %d %d %d %d %d %d %d 50", (unsigned long) rngint(r), EnemyUnti, EnemyUnti, EnemyUnti, EnemyNous, EnemyNous, EnemyNous, EnemyNous, EnemyDa, EnemyDa, EnemyDa, EnemyThu, EnemyGrendu ); break; case 1: pipeadd(&p, "lvlgen", "25 25 3 -s %lu ", (unsigned long) rngint(r)); pipeadd(&p, "itmgen", "-s %lu %d 1", (unsigned long) rngint(r), ItemStatup); pipeadd(&p, "itmgen", "-s %lu %d %d %d %d %d %d %d %d 50", (unsigned long) rngint(r), ItemCopper, ItemCopper, ItemCopper, ItemCopper, ItemSilver, ItemSilver, ItemSilver, ItemGold ); pipeadd(&p, "itmgen", "-s %lu %d %d %d %d %d 5", (unsigned long) rngint(r), ItemHealth, ItemHealth, ItemHealth, ItemCarrot, ItemCarrot ); pipeadd(&p, "itmgen", "-s %lu %d 1", (unsigned long) rngint(r), ItemHamCan); pipeadd(&p, "envgen", "-s %lu %d 1", (unsigned long) rngint(r), EnvShrempty); pipeadd(&p, "envgen", "-s %lu %d %d %d 2", (unsigned long) rngint(r), EnvSwdStoneHp, EnvSwdStoneDex, EnvSwdStoneStr); pipeadd(&p, "envgen", "-s %lu %d %d %d %d 2", (unsigned long)rngint(r), EnvHelm0, EnvBody0, EnvGlove0, EnvBoot0); pipeadd(&p, "enmgen", "-s %lu %d %d %d %d %d %d %d %d %d %d %d %d 50", (unsigned long) rngint(r), EnemyUnti, EnemyUnti, EnemyUnti, EnemyNous, EnemyNous, EnemyNous, EnemyDa, EnemyDa, EnemyDa, EnemyThu, EnemyThu, EnemyGrendu ); break; case 2: pipeadd(&p, "lvlgen", "25 25 3 -s %lu ", (unsigned long) rngint(r)); pipeadd(&p, "itmgen", "-s %lu %d 1", (unsigned long) rngint(r), ItemStatup); pipeadd(&p, "itmgen", "-s %lu %d %d %d %d %d %d %d %d 50", (unsigned long) rngint(r), ItemCopper, ItemCopper, ItemCopper, ItemSilver, ItemSilver, ItemSilver, ItemSilver, ItemGold ); pipeadd(&p, "itmgen", "-s %lu %d %d %d %d %d 5", (unsigned long) rngint(r), ItemHealth, ItemHealth, ItemCarrot, ItemCarrot, ItemCarrot ); pipeadd(&p, "itmgen", "-s %lu %d 1", (unsigned long) rngint(r), ItemHamCan); pipeadd(&p, "itmgen", "-s %lu %d %d %d 1", (unsigned long) rngint(r), ItemBubble, ItemZap, ItemLead ); pipeadd(&p, "envgen", "-s %lu %d 1", (unsigned long) rngint(r), EnvShrempty); pipeadd(&p, "envgen", "-s %lu %d %d %d 2", (unsigned long) rngint(r), EnvSwdStoneHp2, EnvSwdStoneDex2, EnvSwdStoneStr2); pipeadd(&p, "envgen", "-s %lu %d %d %d %d 2", (unsigned long)rngint(r), EnvHelm2, EnvBody2, EnvGlove2, EnvBoot2); pipeadd(&p, "enmgen", "-s %lu %d %d %d %d %d %d %d %d %d %d %d %d 50", (unsigned long) rngint(r), EnemyUnti, EnemyUnti, EnemyUnti, EnemyNous, EnemyNous, EnemyDa, EnemyDa, EnemyDa, EnemyThu, EnemyThu, EnemyGrendu, EnemyGrendu ); break; case 3: pipeadd(&p, "lvlgen", "30 30 3 -s %lu ", (unsigned long) rngint(r)); pipeadd(&p, "itmgen", "-s %lu %d 1", (unsigned long) rngint(r), ItemStatup); pipeadd(&p, "itmgen", "-s %lu %d %d %d %d %d %d %d %d 50", (unsigned long) rngint(r), ItemCopper, ItemSilver, ItemSilver, ItemSilver, ItemGold, ItemGold, ItemGold, ItemGold ); pipeadd(&p, "itmgen", "-s %lu %d %d %d %d %d 4", (unsigned long) rngint(r), ItemHealth, ItemHealth, ItemCarrot, ItemCarrot ); pipeadd(&p, "itmgen", "-s %lu %d 1", (unsigned long) rngint(r), ItemHamCan); pipeadd(&p, "envgen", "-s %lu %d 1", (unsigned long) rngint(r), EnvShrempty); pipeadd(&p, "envgen", "-s %lu %d %d %d 2", (unsigned long) rngint(r), EnvSwdStoneHp2, EnvSwdStoneDex2, EnvSwdStoneStr2); pipeadd(&p, "envgen", "-s %lu %d %d %d %d 2", (unsigned long)rngint(r), EnvHelm2, EnvBody2, EnvGlove2, EnvBoot2); pipeadd(&p, "enmgen", "-s %lu %d %d %d %d %d %d %d %d %d %d %d %d 25", (unsigned long) rngint(r), EnemyUnti, EnemyUnti, EnemyUnti, EnemyNous, EnemyNous, EnemyDa, EnemyDa, EnemyDa, EnemyThu, EnemyThu, EnemyGrendu, EnemyGrendu ); pipeadd(&p, "enmgen", "-s %lu %d %d %d 25", (unsigned long) rngint(r), EnemyThu, EnemyThu, EnemyGrendu ); break; case 4: pipeadd(&p, "lvlgen", "30 30 4 -s %lu ", (unsigned long) rngint(r)); pipeadd(&p, "itmgen", "-s %lu %d 1", (unsigned long) rngint(r), ItemStatup); pipeadd(&p, "itmgen", "-s %lu %d %d %d %d %d %d %d %d 50", (unsigned long) rngint(r), ItemCopper, ItemSilver, ItemSilver, ItemSilver, ItemGold, ItemGold, ItemGold, ItemGold ); pipeadd(&p, "itmgen", "-s %lu %d %d %d %d %d 2", (unsigned long) rngint(r), ItemHealth, ItemCarrot ); pipeadd(&p, "itmgen", "-s %lu %d 1", (unsigned long) rngint(r), ItemHamCan); pipeadd(&p, "itmgen", "-s %lu %d %d %d 1", (unsigned long) rngint(r), ItemBubble, ItemZap, ItemLead ); pipeadd(&p, "envgen", "-s %lu %d 1", (unsigned long) rngint(r), EnvShrempty); pipeadd(&p, "envgen", "-s %lu %d %d %d 2", (unsigned long) rngint(r), EnvSwdStoneHp3, EnvSwdStoneDex3, EnvSwdStoneStr3); pipeadd(&p, "envgen", "-s %lu %d %d %d %d 2", (unsigned long)rngint(r), EnvHelm4, EnvBody4, EnvGlove4, EnvBoot4); pipeadd(&p, "enmgen", "-s %lu %d %d %d %d %d %d %d %d %d %d %d %d 20", (unsigned long) rngint(r), EnemyUnti, EnemyUnti, EnemyUnti, EnemyNous, EnemyNous, EnemyDa, EnemyDa, EnemyDa, EnemyThu, EnemyThu, EnemyGrendu, EnemyGrendu ); pipeadd(&p, "enmgen", "-s %lu %d %d %d %d %d 30", (unsigned long) rngint(r), EnemyThu, EnemyThu, EnemyGrendu, EnemyGrendu, EnemyTihgt ); break; default: pipeadd(&p, "lvlgen", "30 30 4 -x -s %lu ", (unsigned long) rngint(r)); pipeadd(&p, "itmgen", "-s %lu %d 1", (unsigned long) rngint(r), ItemStatup); pipeadd(&p, "itmgen", "-s %lu %d %d %d %d %d %d %d %d 50", (unsigned long) rngint(r), ItemSilver, ItemGold ); pipeadd(&p, "itmgen", "-s %lu %d 1", (unsigned long) rngint(r), ItemHamCan); pipeadd(&p, "envgen", "-s %lu %d 1", (unsigned long) rngint(r), EnvShrempty); pipeadd(&p, "envgen", "-s %lu %d %d %d 2", (unsigned long) rngint(r), EnvSwdStoneHp3, EnvSwdStoneDex3, EnvSwdStoneStr3); pipeadd(&p, "envgen", "-s %lu %d %d %d %d 2", (unsigned long)rngint(r), EnvHelm4, EnvBody4, EnvGlove4, EnvBoot4); pipeadd(&p, "enmgen", "-s %lu %d %d %d %d %d %d %d %d %d %d %d %d 20", (unsigned long) rngint(r), EnemyUnti, EnemyUnti, EnemyUnti, EnemyNous, EnemyNous, EnemyDa, EnemyDa, EnemyDa, EnemyThu, EnemyThu, EnemyGrendu, EnemyGrendu ); pipeadd(&p, "enmgen", "-s %lu %d 15", (unsigned long) rngint(r), EnemyTihgt ); pipeadd(&p, "enmgen", "-s %lu %d 1", (unsigned long) rngint(r), EnemyHeart ); break; } char adc[256]; if(snprintf(adc, sizeof(adc), "\"%s/cur.lvl\"", zonedir) == -1) die("Failed to create cur.lvl path: %s", miderrstr()); pipeadd(&p, "tee", adc); p.cmd[p.n - 3] = 0; pr("lvlgen pipeline: [%s]", p.cmd); FILE *fin = piperead(p.cmd); if (!fin) die("Unable to execute zone gen pipeline: %s", miderrstr()); return fin; }
static int pty_read(struct file *filp, char *buffer, int nbyte, int blocking) { struct pty *pty; struct pipe *pipeb; #if 0 int final = 0,len; #else int total; #endif int foundnl,master; demand(filp, bogus filp); DPRINTF(CLU_LEVEL, ("pty_read: filp: %08x offset: %qd nbyte: %d\n", (int)filp, filp->f_pos, nbyte)); pty = GETPTYP(filp); /* lock_pty(pty); */ master = filp->f_pos; demand (master == 1 || master == 0,master flag set improperly); pipeb = &(pty->pipe[master]); if (!(PTY_BUSY(1 - master,pty)) && pipeb->length == PTY_BUFFER_SIZE) { /* someone closed the other end, and nothing to read */ return 0; } if (pipeb->length == PTY_BUFFER_SIZE && CHECKNB(filp)) { errno = EWOULDBLOCK; return -1; } while(pipeb->length == PTY_BUFFER_SIZE) { /* we block if cant read anything */ unlock_filp(filp); wk_waitfor_value_lt (&pipeb->length, PTY_BUFFER_SIZE, 0); #if 0 yield(-1); #endif lock_filp(filp); } if (!(PTY_BUSY(1 - master,pty)) && pipeb->length == PTY_BUFFER_SIZE) { /* someone closed the other end, and nothing to read */ return 0; } lock_pipepty(pipeb); if (master) { /* master pty does not have line discipline */ total = piperead(pipeb,buffer,nbyte,0,&foundnl); } else { /* slave pty have line discipline */ total = piperead(pipeb,buffer,nbyte,1,&foundnl); } unlock_pipepty(pipeb); /* unlock_pty(pty); */ /* if (master) pr_ptyp(pty); */ return total; }