/**************************************************************************** wait for a process to exit, calling io_flush while waiting ****************************************************************************/ void wait_process(pid_t pid, int *status) { pid_t waited_pid; int cnt; while ((waited_pid = waitpid(pid, status, WNOHANG)) == 0) { msleep(20); io_flush(FULL_FLUSH); } if (waited_pid == -1 && errno == ECHILD) { /* status of requested child no longer available. * check to see if it was processed by the sigchld_handler. */ for (cnt = 0; cnt < MAXCHILDPROCS; cnt++) { if (pid == pid_stat_table[cnt].pid) { *status = pid_stat_table[cnt].status; pid_stat_table[cnt].pid = 0; break; } } } /* TODO: If the child exited on a signal, then log an * appropriate error message. Perhaps we should also accept a * message describing the purpose of the child. Also indicate * this to the caller so that thhey know something went * wrong. */ *status = WEXITSTATUS(*status); }
void block_io_write_int8( block_io *io, uint8_t val ) { if ( io->left == 0 ) io_flush(io); io->left -= 1; *(io->ptr++) = val; }
ssize_t memcached_io_write(memcached_server_st *ptr, const void *buffer, size_t length, char with_flush) { size_t original_length; const char* buffer_ptr; original_length= length; buffer_ptr= buffer; while (length) { char *write_ptr; size_t should_write; should_write= MEMCACHED_MAX_BUFFER - ptr->write_buffer_offset; write_ptr= ptr->write_buffer + ptr->write_buffer_offset; should_write= (should_write < length) ? should_write : length; memcpy(write_ptr, buffer_ptr, should_write); ptr->write_buffer_offset+= should_write; buffer_ptr+= should_write; length-= should_write; if (ptr->write_buffer_offset == MEMCACHED_MAX_BUFFER) { memcached_return rc; ssize_t sent_length; sent_length= io_flush(ptr, &rc); if (sent_length == -1) return -1; WATCHPOINT_ASSERT(sent_length == MEMCACHED_MAX_BUFFER); } } if (with_flush) { memcached_return rc; if (io_flush(ptr, &rc) == -1) return -1; } return original_length; }
void VUTermContinue() { ioctl(STDIN, TIOCSETN, &new_stty); io_escape(term->term_startup); io_flush(); cr = cc = -1; statline[0] = 0; VUForceRedraw(); }
void VUTermContinue() { tcsetattr(STDIN, TCSADRAIN, &new_stty); io_escape(term->term_startup); io_flush(); cc = cr = -1; statline[0] = 0; VUForceRedraw(); }
void VUTermSuspend(BOOL cls) { setattr(DARKWHITE | BLACK); if(cls) { cursor(0, 0); io_puts(term->term_eop); } else { cursor(rows - 1, 0); io_puts(term->term_eol); } if(cls != 2) { io_escape(term->term_cursor_show); io_escape(term->term_shutdown); io_flush(); tcsetattr(STDIN, TCSANOW, &old_stty); } else io_flush(); }
int privsep_send(struct io *io, struct msg *msg, struct msgbuf *msgbuf) { char *cause; msg->size = 0; if (msgbuf != NULL && msgbuf->buf != NULL && msgbuf->len > 0) msg->size = msgbuf->len; io_write(io, msg, sizeof *msg); if (io_flush(io, INFTIM, &cause) != 0) return (-1); if (msg->size != 0) { io_write(io, msgbuf->buf, msgbuf->len); if (io_flush(io, INFTIM, &cause) != 0) return (-1); } return (0); }
void VUTermSuspend(BOOL cls) { setattr(DARKWHITE | BLACK); if(cls) { cursor(0, 0); io_puts(term->term_cls); } else { cursor(rows - 1, 0); io_puts(term->term_eol); } io_escape(term->term_cursor_show); io_escape(term->term_shutdown); io_flush(); ioctl(STDIN, TIOCSETN, &old_stty); }
static void unclosable_flush(void* _self) { UnclosableOutput* self = _self; io_flush(self->wrap); }
static void on_netlink_read(struct io *io, void *fsv) { struct dfs *fs = (struct dfs *)fsv; char *b = io->buffer, *fragment_header = b, *is = b, *ms = b, *i = b, *max = (b + io->length), frag_boundary = 0; sexpr attributes = sx_end_of_list; while (i < max) { frag_boundary = 0; switch (*i) { case 0: if (i == (max - 1)) /* definitely a fragment end */ { frag_boundary = 1; } if (is == ms) /* fragment header */ { if (is != b) /* first fragment header: nothing to examine */ { attributes = cons(make_symbol (fragment_header), attributes); dev9_rules_apply (attributes, fs); } fragment_header = is; attributes = sx_end_of_list; } else /* key/value pair */ { *ms = 0; attributes = cons (cons(make_symbol(is), make_string(ms+1)), attributes); *ms = '='; } i++; is = ms = i; break; case '=': if (ms == is) ms = i; } i++; } if (frag_boundary) { attributes = cons(make_symbol (fragment_header), attributes); dev9_rules_apply (attributes, fs); io->position += io->length; } else { io->position += (int_pointer)(max - fragment_header); } optimise_static_memory_pools(); io_flush (io); }
int deliver_smtp_deliver(struct deliver_ctx *dctx, struct actitem *ti) { struct account *a = dctx->account; struct mail *m = dctx->mail; struct deliver_smtp_data *data = ti->data; int done, code; struct io *io; char *cause, *to, *from, *line, *ptr, *lbuf; enum deliver_smtp_state state; size_t len, llen; io = connectproxy(&data->server, conf.verify_certs, conf.proxy, IO_CRLF, conf.timeout, &cause); if (io == NULL) { log_warnx("%s: %s", a->name, cause); xfree(cause); return (DELIVER_FAILURE); } if (conf.debug > 3 && !conf.syslog) io->dup_fd = STDOUT_FILENO; llen = IO_LINESIZE; lbuf = xmalloc(llen); if (conf.host_fqdn != NULL) xasprintf(&ptr, "%s@%s", dctx->udata->name, conf.host_fqdn); else xasprintf(&ptr, "%s@%s", dctx->udata->name, conf.host_name); if (data->to.str == NULL) to = xstrdup(ptr); else { to = replacestr(&data->to, m->tags, m, &m->rml); if (to == NULL || *to == '\0') { xasprintf(&cause, "%s: empty to", a->name); from = NULL; goto error; } } if (data->from.str == NULL) from = xstrdup(ptr); else { from = replacestr(&data->from, m->tags, m, &m->rml); if (from == NULL || *from == '\0') { xasprintf(&cause, "%s: empty from", a->name); goto error; } } xfree(ptr); state = SMTP_CONNECTING; line = NULL; done = 0; do { switch (io_pollline2(io, &line, &lbuf, &llen, conf.timeout, &cause)) { case 0: cause = xstrdup("connection unexpectedly closed"); goto error; case -1: goto error; } code = deliver_smtp_code(line); cause = NULL; switch (state) { case SMTP_CONNECTING: if (code != 220) goto error; state = SMTP_HELO; if (conf.host_fqdn != NULL) io_writeline(io, "HELO %s", conf.host_fqdn); else io_writeline(io, "HELO %s", conf.host_name); break; case SMTP_HELO: if (code != 250) goto error; state = SMTP_FROM; io_writeline(io, "MAIL FROM:<%s>", from); break; case SMTP_FROM: if (code != 250) goto error; state = SMTP_TO; io_writeline(io, "RCPT TO:<%s>", to); break; case SMTP_TO: if (code != 250) goto error; state = SMTP_DATA; io_writeline(io, "DATA"); break; case SMTP_DATA: if (code != 354) goto error; line_init(m, &ptr, &len); while (ptr != NULL) { if (len > 1) { if (*ptr == '.') io_write(io, ".", 1); io_write(io, ptr, len - 1); } io_writeline(io, NULL); /* Update if necessary. */ if (io_update(io, conf.timeout, &cause) != 1) goto error; line_next(m, &ptr, &len); } state = SMTP_DONE; io_writeline(io, "."); io_flush(io, conf.timeout, NULL); break; case SMTP_DONE: if (code != 250) goto error; state = SMTP_QUIT; io_writeline(io, "QUIT"); break; case SMTP_QUIT: /* * Exchange sometimes refuses to accept QUIT as a valid * command, but since we got a 250 the mail has been * accepted. So, allow 500 here too. */ if (code != 500 && code != 221) goto error; done = 1; break; } } while (!done); xfree(lbuf); xfree(from); xfree(to); io_close(io); io_free(io); return (DELIVER_SUCCESS); error: if (cause != NULL) { log_warnx("%s: %s", a->name, cause); xfree(cause); } else log_warnx("%s: unexpected response: %s", a->name, line); io_writeline(io, "QUIT"); io_flush(io, conf.timeout, NULL); xfree(lbuf); if (from != NULL) xfree(from); if (to != NULL) xfree(to); io_close(io); io_free(io); return (DELIVER_FAILURE); }
void CMain::JSONUpdateThread(void *pUser) { CJSONUpdateThreadData *m_pJSONUpdateThreadData = (CJSONUpdateThreadData *)pUser; CClient *pClients = m_pJSONUpdateThreadData->pClients; CConfig *pConfig = m_pJSONUpdateThreadData->pConfig; while(gs_Running) { char aFileBuf[2048*NET_MAX_CLIENTS]; char *pBuf = aFileBuf; str_format(pBuf, sizeof(aFileBuf), "{\n\"servers\": [\n"); pBuf += strlen(pBuf); for(int i = 0; i < NET_MAX_CLIENTS; i++) { if(!pClients[i].m_Active || pClients[i].m_Disabled) continue; if(pClients[i].m_Connected) { // Connectivity bool Online4; bool Online6; Online4 = pClients[i].m_Stats.m_Online4; Online6 = pClients[i].m_Stats.m_Online6; // Uptime char aUptime[16]; int Days = pClients[i].m_Stats.m_Uptime/60.0/60.0/24.0; if(Days > 0) { if(Days > 1) str_format(aUptime, sizeof(aUptime), "%d days", Days); else str_format(aUptime, sizeof(aUptime), "%d day", Days); } else str_format(aUptime, sizeof(aUptime), "%02d:%02d:%02d", (int)(pClients[i].m_Stats.m_Uptime/60.0/60.0), (int)((pClients[i].m_Stats.m_Uptime/60)%60), (int)((pClients[i].m_Stats.m_Uptime)%60)); // Load float Load = pClients[i].m_Stats.m_Load; // CPU int CPU = pClients[i].m_Stats.m_CPU; // Memory int Memory; if(pClients[i].m_Stats.m_MemTotal) Memory = round(((float)pClients[i].m_Stats.m_MemUsed/pClients[i].m_Stats.m_MemTotal)*100.0); else Memory = 0; // HDD int HDD; if(pClients[i].m_Stats.m_HDDTotal) HDD = round(((float)pClients[i].m_Stats.m_HDDUsed/pClients[i].m_Stats.m_HDDTotal)*100.0); else HDD = 0; str_format(pBuf, sizeof(aFileBuf) - (pBuf - aFileBuf), "{ \"name\": \"%s\", \"type\": \"%s\", \"host\": \"%s\", \"location\": \"%s\", \"online4\": %s, \"online6\": %s, \"uptime\": \"%s\", \"load\": \"%.2f\", \"network_rx\": %d, \"network_tx\": %d, \"cpu\": %d, \"memory\": %d, \"memory_total\": %" PRId64 ", \"memory_used\": %" PRId64 ", \"hdd\": %d, \"hdd_total\": %" PRId64 ", \"hdd_used\": %" PRId64 " },\n", pClients[i].m_aName, pClients[i].m_aType, pClients[i].m_aHost, pClients[i].m_aLocation, Online4 ? "true" : "false", Online6 ? "true" : "false", aUptime, Load, pClients[i].m_Stats.m_NetworkRx, pClients[i].m_Stats.m_NetworkTx, CPU, Memory, pClients[i].m_Stats.m_MemTotal, pClients[i].m_Stats.m_MemUsed, HDD, pClients[i].m_Stats.m_HDDTotal, pClients[i].m_Stats.m_HDDUsed); pBuf += strlen(pBuf); } else { str_format(pBuf, sizeof(aFileBuf) - (pBuf - aFileBuf), "{ \"name\": \"%s\", \"type\": \"%s\", \"host\": \"%s\", \"location\": \"%s\", \"online4\": false, \"online6\": false },\n", pClients[i].m_aName, pClients[i].m_aType, pClients[i].m_aHost, pClients[i].m_aLocation); pBuf += strlen(pBuf); } } if(!m_pJSONUpdateThreadData->m_ReloadRequired) str_format(pBuf - 2, sizeof(aFileBuf) - (pBuf - aFileBuf), "\n],\n\"updated\": \"%lld\"\n}", (long long)time(/*ago*/0)); else { str_format(pBuf - 2, sizeof(aFileBuf) - (pBuf - aFileBuf), "\n],\n\"updated\": \"%lld\",\n\"reload\": true\n}", (long long)time(/*ago*/0)); m_pJSONUpdateThreadData->m_ReloadRequired--; } pBuf += strlen(pBuf); char aJSONFileTmp[1024]; str_format(aJSONFileTmp, sizeof(aJSONFileTmp), "%s~", pConfig->m_aJSONFile); IOHANDLE File = io_open(aJSONFileTmp, IOFLAG_WRITE); if(!File) { dbg_msg("main", "Couldn't open %s", aJSONFileTmp); exit(1); } io_write(File, aFileBuf, (pBuf - aFileBuf)); io_flush(File); io_close(File); fs_rename(aJSONFileTmp, pConfig->m_aJSONFile); thread_sleep(1000); } fs_remove(pConfig->m_aJSONFile); }
int lite_PD_flush (PDBfile *file) { FILE *fp; if (file->flushed) return(TRUE); if (file->attrtab != NULL) { lite_PD_cd(file, NULL); if (!lite_PD_write(file, PDB_ATTRIBUTE_TABLE, "HASHTAB *", &file->attrtab)) { return(FALSE); } } switch (setjmp(_lite_PD_write_err)) { case ABORT: return(FALSE); case ERR_FREE: return(TRUE); default: memset(lite_PD_err, 0, MAXLINE); break; } fp = file->stream; if (io_flush(fp)) { lite_PD_error("FFLUSH FAILED BEFORE CHART - PD_FLUSH", PD_WRITE); } /* * Seek the place to write the structure chart. */ if (io_seek(fp, file->chrtaddr, SEEK_SET)) { lite_PD_error("FSEEK FAILED TO FIND CHART - PD_FLUSH", PD_WRITE); } /* * Write the structure chart. */ file->chrtaddr = _lite_PD_wr_chrt(file); if (file->chrtaddr == -1L) { lite_PD_error("CAN'T WRITE STRUCTURE CHART - PD_FLUSH", PD_WRITE); } /* * Write the symbol table. */ file->symtaddr = _lite_PD_wr_symt(file); if (file->symtaddr == -1L) { lite_PD_error("CAN'T WRITE SYMBOL TABLE - PD_FLUSH", PD_WRITE); } /* * Write the extras table. */ if (!_lite_PD_wr_extras(file)) { lite_PD_error("CAN'T WRITE MISCELLANEOUS DATA - PD_FLUSH", PD_WRITE); } if (io_tell(fp) == -1L) { lite_PD_error("CAN'T FIND HEADER ADDRESS - PD_FLUSH", PD_WRITE); } if (io_flush(fp)) { lite_PD_error("FFLUSH FAILED AFTER CHART - PD_FLUSH", PD_WRITE); } /* * Update the header. */ if (io_seek(fp, file->headaddr, SEEK_SET)) { lite_PD_error("FSEEK FAILED - PD_FLUSH", PD_WRITE); } if (file->headaddr != io_tell(fp)) { lite_PD_error("FSEEK FAILED TO FIND HEADER - PD_FLUSH", PD_WRITE); } io_printf(fp, "%ld\001%ld\001\n", file->chrtaddr, file->symtaddr); if (io_flush(fp)) { lite_PD_error("FFLUSH FAILED AFTER HEADER - PD_FLUSH", PD_WRITE); } file->flushed = TRUE; return(TRUE); }
/* * This is called once the connection has been negotiated. It is used * for rsyncd, remote-shell, and local connections. */ int client_run(int f_in, int f_out, pid_t pid, int argc, char *argv[]) { struct file_list *flist = NULL; int status = 0, status2 = 0; char *local_name = NULL; cleanup_child_pid = pid; if (!read_batch) { set_nonblocking(f_in); set_nonblocking(f_out); } io_set_sock_fds(f_in, f_out); setup_protocol(f_out,f_in); if (protocol_version >= 23 && !read_batch) io_start_multiplex_in(); /* We set our stderr file handle to blocking because ssh might have * set it to non-blocking. This can be particularly troublesome if * stderr is a clone of stdout, because ssh would have set our stdout * to non-blocking at the same time (which can easily cause us to lose * output from our print statements). This kluge shouldn't cause ssh * any problems for how we use it. Note also that we delayed setting * this until after the above protocol setup so that we know for sure * that ssh is done twiddling its file descriptors. */ set_blocking(STDERR_FILENO); if (am_sender) { keep_dirlinks = 0; /* Must be disabled on the sender. */ io_start_buffering_out(); if (!filesfrom_host) set_msg_fd_in(f_in); send_filter_list(f_out); if (filesfrom_host) filesfrom_fd = f_in; if (write_batch && !am_server) start_write_batch(f_out); flist = send_file_list(f_out, argc, argv); set_msg_fd_in(-1); if (verbose > 3) rprintf(FINFO,"file list sent\n"); the_file_list = flist; io_flush(NORMAL_FLUSH); send_files(flist,f_out,f_in); io_flush(FULL_FLUSH); handle_stats(-1); if (protocol_version >= 24) read_final_goodbye(f_in, f_out); if (pid != -1) { if (verbose > 3) rprintf(FINFO,"client_run waiting on %d\n", (int) pid); io_flush(FULL_FLUSH); wait_process(pid, &status); } output_summary(); io_flush(FULL_FLUSH); exit_cleanup(status); } if (need_messages_from_generator && !read_batch) io_start_multiplex_out(); if (argc == 0) list_only |= 1; send_filter_list(read_batch ? -1 : f_out); if (filesfrom_fd >= 0) { io_set_filesfrom_fds(filesfrom_fd, f_out); filesfrom_fd = -1; } if (write_batch && !am_server) start_write_batch(f_in); flist = recv_file_list(f_in); the_file_list = flist; if (flist && flist->count > 0) { local_name = get_local_name(flist, argv[0]); status2 = do_recv(f_in, f_out, flist, local_name); } else { handle_stats(-1); output_summary(); } if (pid != -1) { if (verbose > 3) rprintf(FINFO,"client_run2 waiting on %d\n", (int) pid); io_flush(FULL_FLUSH); wait_process(pid, &status); } return MAX(status, status2); }
static int do_recv(int f_in,int f_out,struct file_list *flist,char *local_name) { int pid; int status = 0; int error_pipe[2]; /* The receiving side mustn't obey this, or an existing symlink that * points to an identical file won't be replaced by the referent. */ copy_links = 0; if (preserve_hard_links) init_hard_links(); if (fd_pair(error_pipe) < 0) { rsyserr(FERROR, errno, "pipe failed in do_recv"); exit_cleanup(RERR_IPC); } io_flush(NORMAL_FLUSH); if ((pid = do_fork()) == -1) { rsyserr(FERROR, errno, "fork failed in do_recv"); exit_cleanup(RERR_IPC); } if (pid == 0) { close(error_pipe[0]); if (f_in != f_out) close(f_out); /* we can't let two processes write to the socket at one time */ close_multiplexing_out(); /* set place to send errors */ set_msg_fd_out(error_pipe[1]); recv_files(f_in, flist, local_name); io_flush(FULL_FLUSH); handle_stats(f_in); send_msg(MSG_DONE, "", 0); io_flush(FULL_FLUSH); /* Handle any keep-alive packets from the post-processing work * that the generator does. */ if (protocol_version >= 29) { kluge_around_eof = -1; /* This should only get stopped via a USR2 signal. */ while (read_int(f_in) == flist->count && read_shortint(f_in) == ITEM_IS_NEW) {} rprintf(FERROR, "Invalid packet at end of run [%s]\n", who_am_i()); exit_cleanup(RERR_PROTOCOL); } /* Finally, we go to sleep until our parent kills us with a * USR2 signal. We sleep for a short time, as on some OSes * a signal won't interrupt a sleep! */ while (1) msleep(20); } am_generator = 1; close_multiplexing_in(); if (write_batch && !am_server) stop_write_batch(); close(error_pipe[1]); if (f_in != f_out) close(f_in); io_start_buffering_out(); set_msg_fd_in(error_pipe[0]); generate_files(f_out, flist, local_name); handle_stats(-1); io_flush(FULL_FLUSH); if (protocol_version >= 24) { /* send a final goodbye message */ write_int(f_out, -1); } io_flush(FULL_FLUSH); set_msg_fd_in(-1); kill(pid, SIGUSR2); wait_process(pid, &status); return status; }
static void do_server_sender(int f_in, int f_out, int argc,char *argv[]) { int i; struct file_list *flist; char *dir = argv[0]; if (verbose > 2) { rprintf(FINFO, "server_sender starting pid=%ld\n", (long)getpid()); } if (am_daemon && lp_write_only(module_id)) { rprintf(FERROR, "ERROR: module is write only\n"); exit_cleanup(RERR_SYNTAX); return; } if (am_daemon && lp_read_only(module_id) && remove_sent_files) { rprintf(FERROR, "ERROR: --remove-sent-files cannot be used with a read-only module\n"); exit_cleanup(RERR_SYNTAX); return; } if (!relative_paths && !push_dir(dir)) { rsyserr(FERROR, errno, "push_dir#3 %s failed", full_fname(dir)); exit_cleanup(RERR_FILESELECT); } argc--; argv++; if (strcmp(dir,".")) { int l = strlen(dir); if (strcmp(dir,"/") == 0) l = 0; for (i = 0; i < argc; i++) argv[i] += l+1; } if (argc == 0 && (recurse || list_only)) { argc = 1; argv--; argv[0] = "."; } flist = send_file_list(f_out,argc,argv); if (!flist || flist->count == 0) { exit_cleanup(0); } the_file_list = flist; io_start_buffering_in(); io_start_buffering_out(); send_files(flist,f_out,f_in); io_flush(FULL_FLUSH); handle_stats(f_out); if (protocol_version >= 24) read_final_goodbye(f_in, f_out); io_flush(FULL_FLUSH); exit_cleanup(0); }
PDBfile * lite_PD_create (char *name) { char str[MAXLINE]; PDBfile *file; static FILE *fp; file = NULL; switch (setjmp(_lite_PD_create_err)) { case ABORT: if (fp) io_close(fp); return(NULL); case ERR_FREE: return(file); default: memset(lite_PD_err, 0, MAXLINE); break; } /* * Open the file. */ strncpy(str, name, sizeof(str)); str[sizeof(str)-1] = '\0'; fp = io_open(str, BINARY_MODE_WPLUS); if (!fp) lite_PD_error("CAN'T CREATE FILE - PD_CREATE", PD_CREATE); if (lite_PD_buffer_size != -1) { if (io_setvbuf(fp, NULL, _IOFBF, (size_t) lite_PD_buffer_size)) { lite_PD_error("CAN'T SET FILE BUFFER - PD_CREATE", PD_OPEN); } } /* * Make the PDBfile. */ file = _lite_PD_mk_pdb(str, lite_PD_DEF_CREATM); if (file == NULL) { lite_PD_error("CAN'T ALLOCATE PDBFILE - PD_CREATE", PD_OPEN); } file->stream = fp; file->mode = PD_CREATE; /* * Set the file data conversion standard - and yes someone might pick * a target standard which is the current standard */ file->std = _lite_PD_copy_standard(file->host_std); file->align = _lite_PD_copy_alignment(file->host_align); if (lite_REQ_STANDARD != NULL) { if (!_lite_PD_compare_std(lite_REQ_STANDARD, file->std, lite_REQ_ALIGNMENT, file->align)) { _lite_PD_rl_standard(file->std); file->std = _lite_PD_copy_standard(lite_REQ_STANDARD); _lite_PD_rl_alignment(file->align); file->align = _lite_PD_copy_alignment(lite_REQ_ALIGNMENT); } lite_REQ_STANDARD = NULL; } /* * Write the ASCII header. */ io_printf(fp, "%s\n", HeadTok); if (io_flush(fp)) { lite_PD_error("FFLUSH FAILED BEFORE HEADER - PD_CREATE", PD_CREATE); } /* * Write the primitive data type formats. */ if (!_lite_PD_wr_format(file)) { lite_PD_error("FAILED TO WRITE FORMATS - PD_CREATE", PD_CREATE); } /* * Record the current file position as the location of the symbol table * address and sequentially the chart address */ if ((file->headaddr = io_tell(fp)) == -1L) { lite_PD_error("CAN'T FIND HEADER ADDRESS - PD_CREATE", PD_CREATE); } /* * Initialize the pdb system defs and structure chart. */ _lite_PD_init_chrt(file); if (io_flush(fp)) { lite_PD_error("FFLUSH FAILED AFTER HEADER - PD_CREATE", PD_CREATE); } memset(str, 0, PAD_SIZE); if (io_write(str, (size_t) 1, PAD_SIZE, fp) != PAD_SIZE) { lite_PD_error("FAILED TO PAD FILE FOR MPW - PD_CREATE", PD_CREATE); } file->chrtaddr = file->headaddr + 128L; if (io_seek(fp, file->chrtaddr, SEEK_SET)) { lite_PD_error("FAILED TO FIND START OF DATA - PD_CREATE", PD_CREATE); } file->system_version = PDB_SYSTEM_VERSION; file->date = lite_SC_date(); return(file); }
int deliver_imap_deliver(struct deliver_ctx *dctx, struct actitem *ti) { struct account *a = dctx->account; struct mail *m = dctx->mail; struct deliver_imap_data *data = ti->data; struct io *io; struct fetch_ctx fctx; struct fetch_imap_data fdata; char *cause, *folder, *ptr, *line; size_t len, maillen; u_int total, body; /* Connect to the IMAP server. */ io = connectproxy(&data->server, conf.verify_certs, conf.proxy, IO_CRLF, conf.timeout, &cause); if (io == NULL) { log_warnx("%s: %s", a->name, cause); xfree(cause); return (DELIVER_FAILURE); } if (conf.debug > 3 && !conf.syslog) io->dup_fd = STDOUT_FILENO; /* Work out the folder name. */ folder = replacestr(&data->folder, m->tags, m, &m->rml); if (folder == NULL || *folder == '\0') { log_warnx("%s: empty folder", a->name); goto error; } /* Fake up the fetch context for the fetch code. */ memset(&fdata, 0, sizeof fdata); fdata.user = data->user; fdata.pass = data->pass; fdata.nocrammd5 = data->nocrammd5; fdata.nologin = data->nologin; memcpy(&fdata.server, &data->server, sizeof fdata.server); fdata.io = io; fdata.only = FETCH_ONLY_ALL; a->data = &fdata; fetch_imap_state_init(a, &fctx); fctx.state = imap_state_connected; fctx.llen = IO_LINESIZE; fctx.lbuf = xmalloc(fctx.llen); /* Use the fetch code until the select1 state is reached. */ if (deliver_imap_pollto(imap_state_select1, a, io, &fctx) != 0) goto error; retry: /* Send an append command. */ if (imap_putln(a, "%u APPEND {%zu}", ++fdata.tag, strlen(folder)) != 0) goto error; switch (deliver_imap_waitappend(a, &fctx, io, &line)) { case IMAP_TAG_ERROR: if (line != NULL) imap_invalid(a, line); goto error; case IMAP_TAG_CONTINUE: break; default: if (imap_no(line) && strstr(line, "[TRYCREATE]") != NULL) goto try_create; imap_invalid(a, line); goto error; } /* * Send the mail size, not forgetting lines are CRLF terminated. The * Google IMAP server is written strangely, so send the size as if * every CRLF was a CR if the server has XYZZY. */ count_lines(m, &total, &body); maillen = m->size + total - 1; if (fdata.capa & IMAP_CAPA_XYZZY) { log_debug2("%s: adjusting size: actual %zu", a->name, maillen); maillen = m->size; } if (fdata.capa & IMAP_CAPA_NOSPACE) { if (imap_putln(a, "%s{%zu}", folder, maillen) != 0) goto error; } else { if (imap_putln(a, "%s {%zu}", folder, maillen) != 0) goto error; } switch (deliver_imap_waitappend(a, &fctx, io, &line)) { case IMAP_TAG_ERROR: if (line != NULL) imap_invalid(a, line); goto error; case IMAP_TAG_CONTINUE: break; default: if (imap_no(line) && strstr(line, "[TRYCREATE]") != NULL) goto try_create; imap_invalid(a, line); goto error; } /* Send the mail data. */ line_init(m, &ptr, &len); while (ptr != NULL) { if (len > 1) io_write(io, ptr, len - 1); io_writeline(io, NULL); /* Update if necessary. */ if (io_update(io, conf.timeout, &cause) != 1) { log_warnx("%s: %s", a->name, cause); xfree(cause); goto error; } line_next(m, &ptr, &len); } /* Wait for an okay from the server. */ switch (deliver_imap_waitappend(a, &fctx, io, &line)) { case IMAP_TAG_ERROR: case IMAP_TAG_CONTINUE: if (line != NULL) imap_invalid(a, line); goto error; default: if (imap_okay(line)) break; if (strstr(line, "[TRYCREATE]") != NULL) goto try_create; imap_invalid(a, line); goto error; } xfree(fctx.lbuf); xfree(folder); if (imap_putln(a, "%u LOGOUT", ++fdata.tag) != 0) goto error; if (deliver_imap_waitokay(a, &fctx, io, &line) != 0) goto error; fdata.disconnect(a); return (DELIVER_SUCCESS); try_create: /* XXX function? */ /* Try to create the folder. */ if (imap_putln(a, "%u CREATE {%zu}", ++fdata.tag, strlen(folder)) != 0) goto error; if (deliver_imap_waitcontinue(a, &fctx, io, &line) != 0) goto error; if (imap_putln(a, "%s", folder) != 0) goto error; if (deliver_imap_waitokay(a, &fctx, io, &line) != 0) goto error; goto retry; error: io_writeline(io, "QUIT"); io_flush(io, conf.timeout, NULL); xfree(fctx.lbuf); if (folder != NULL) xfree(folder); fdata.disconnect(a); return (DELIVER_FAILURE); }
/** * Eventually calls exit(), passing @p code, therefore does not return. * * @param code one of the RERR_* codes from errcode.h. **/ NORETURN void _exit_cleanup(int code, const char *file, int line) { static int switch_step = 0; static int exit_code = 0, exit_line = 0; static const char *exit_file = NULL; static int first_code = 0; SIGACTION(SIGUSR1, SIG_IGN); SIGACTION(SIGUSR2, SIG_IGN); if (!exit_code) { /* Preserve first error exit info when recursing. */ exit_code = code; exit_file = file; exit_line = line < 0 ? -line : line; } /* If this is the exit at the end of the run, the server side * should not attempt to output a message (see log_exit()). */ if (am_server && code == 0) am_server = 2; /* Some of our actions might cause a recursive call back here, so we * keep track of where we are in the cleanup and never repeat a step. */ switch (switch_step) { #include "case_N.h" /* case 0: */ switch_step++; first_code = code; if (output_needs_newline) { fputc('\n', stdout); output_needs_newline = 0; } if (DEBUG_GTE(EXIT, 2)) { rprintf(FINFO, "[%s] _exit_cleanup(code=%d, file=%s, line=%d): entered\n", who_am_i(), code, file, line); } /* FALLTHROUGH */ #include "case_N.h" switch_step++; if (cleanup_child_pid != -1) { int status; int pid = wait_process(cleanup_child_pid, &status, WNOHANG); if (pid == cleanup_child_pid) { status = WEXITSTATUS(status); if (status > exit_code) exit_code = status; } } /* FALLTHROUGH */ #include "case_N.h" switch_step++; if (cleanup_got_literal && (cleanup_fname || cleanup_fd_w != -1)) { if (cleanup_fd_r != -1) { close(cleanup_fd_r); cleanup_fd_r = -1; } if (cleanup_fd_w != -1) { flush_write_file(cleanup_fd_w); close(cleanup_fd_w); cleanup_fd_w = -1; } if (cleanup_fname && cleanup_new_fname && keep_partial && handle_partial_dir(cleanup_new_fname, PDIR_CREATE)) { int tweak_modtime = 0; const char *fname = cleanup_fname; cleanup_fname = NULL; if (!partial_dir) { /* We don't want to leave a partial file with a modern time or it * could be skipped via --update. Setting the time to something * really old also helps it to stand out as unfinished in an ls. */ tweak_modtime = 1; cleanup_file->modtime = 0; } finish_transfer(cleanup_new_fname, fname, NULL, NULL, cleanup_file, tweak_modtime, !partial_dir); } } /* FALLTHROUGH */ #include "case_N.h" switch_step++; if (flush_ok_after_signal) { flush_ok_after_signal = False; if (code == RERR_SIGNAL) io_flush(FULL_FLUSH); } if (!exit_code && !code) io_flush(FULL_FLUSH); /* FALLTHROUGH */ #include "case_N.h" switch_step++; if (cleanup_fname) do_unlink(cleanup_fname); if (exit_code) kill_all(SIGUSR1); if (cleanup_pid && cleanup_pid == getpid()) { char *pidf = lp_pid_file(); if (pidf && *pidf) unlink(lp_pid_file()); } if (exit_code == 0) { if (code) exit_code = code; if (io_error & IOERR_DEL_LIMIT) exit_code = RERR_DEL_LIMIT; if (io_error & IOERR_VANISHED) exit_code = RERR_VANISHED; if (io_error & IOERR_GENERAL || got_xfer_error) exit_code = RERR_PARTIAL; } /* If line < 0, this exit is after a MSG_ERROR_EXIT event, so * we don't want to output a duplicate error. */ if ((exit_code && line > 0) || am_daemon || (logfile_name && (am_server || !INFO_GTE(STATS, 1)))) log_exit(exit_code, exit_file, exit_line); /* FALLTHROUGH */ #include "case_N.h" switch_step++; if (DEBUG_GTE(EXIT, 1)) { rprintf(FINFO, "[%s] _exit_cleanup(code=%d, file=%s, line=%d): " "about to call exit(%d)\n", who_am_i(), first_code, exit_file, exit_line, exit_code); } /* FALLTHROUGH */ #include "case_N.h" switch_step++; if (exit_code && exit_code != RERR_SOCKETIO && exit_code != RERR_STREAMIO && exit_code != RERR_SIGNAL1 && exit_code != RERR_TIMEOUT && !shutting_down && (protocol_version >= 31 || am_receiver)) { if (line > 0) { if (DEBUG_GTE(EXIT, 3)) { rprintf(FINFO, "[%s] sending MSG_ERROR_EXIT with exit_code %d\n", who_am_i(), exit_code); } send_msg_int(MSG_ERROR_EXIT, exit_code); } noop_io_until_death(); } /* FALLTHROUGH */ #include "case_N.h" switch_step++; if (am_server && exit_code) msleep(100); close_all(); /* FALLTHROUGH */ default: break; } exit(exit_code); }
/** * Eventually calls exit(), passing @p code, therefore does not return. * * @param code one of the RERR_* codes from errcode.h. **/ NORETURN void _exit_cleanup(int code, const char *file, int line) { static int switch_step = 0; static int exit_code = 0, exit_line = 0; static const char *exit_file = NULL; static int unmodified_code = 0; SIGACTION(SIGUSR1, SIG_IGN); SIGACTION(SIGUSR2, SIG_IGN); if (exit_code) { /* Preserve first exit info when recursing. */ code = exit_code; file = exit_file; line = exit_line; } /* If this is the exit at the end of the run, the server side * should not attempt to output a message (see log_exit()). */ if (am_server && code == 0) am_server = 2; /* Some of our actions might cause a recursive call back here, so we * keep track of where we are in the cleanup and never repeat a step. */ switch (switch_step) { #include "case_N.h" /* case 0: */ switch_step++; exit_code = unmodified_code = code; exit_file = file; exit_line = line; if (verbose > 3) { rprintf(FINFO, "[%s] _exit_cleanup(code=%d, file=%s, line=%d): entered\n", who_am_i(), code, file, line); } /* FALLTHROUGH */ #include "case_N.h" switch_step++; if (cleanup_child_pid != -1) { int status; int pid = wait_process(cleanup_child_pid, &status, WNOHANG); if (pid == cleanup_child_pid) { status = WEXITSTATUS(status); if (status > code) code = exit_code = status; } } /* FALLTHROUGH */ #include "case_N.h" switch_step++; if (cleanup_got_literal && cleanup_fname && cleanup_new_fname && keep_partial && handle_partial_dir(cleanup_new_fname, PDIR_CREATE)) { const char *fname = cleanup_fname; cleanup_fname = NULL; if (cleanup_fd_r != -1) bpc_close(cleanup_fd_r); if (cleanup_fd_w != -1) { flush_write_file(cleanup_fd_w); bpc_close(cleanup_fd_w); } finish_transfer(cleanup_new_fname, fname, NULL, NULL, cleanup_file, 0, !partial_dir); } /* FALLTHROUGH */ #include "case_N.h" switch_step++; if (!code || am_server || am_receiver) io_flush(FULL_FLUSH); /* FALLTHROUGH */ #include "case_N.h" switch_step++; bpc_sysCall_cleanup(); if (cleanup_fname) do_unlink(cleanup_fname); if (code) kill_all(SIGUSR1); if (cleanup_pid && cleanup_pid == getpid()) { char *pidf = lp_pid_file(); if (pidf && *pidf) unlink(lp_pid_file()); } if (code == 0) { if (io_error & IOERR_DEL_LIMIT) code = exit_code = RERR_DEL_LIMIT; if (io_error & IOERR_VANISHED) code = exit_code = RERR_VANISHED; if (io_error & IOERR_GENERAL || got_xfer_error) code = exit_code = RERR_PARTIAL; } if (code || am_daemon || (logfile_name && (am_server || !verbose))) log_exit(code, file, line); /* FALLTHROUGH */ #include "case_N.h" switch_step++; if (verbose > 2) { rprintf(FINFO, "[%s] _exit_cleanup(code=%d, file=%s, line=%d): " "about to call exit(%d)\n", who_am_i(), unmodified_code, file, line, code); } /* FALLTHROUGH */ #include "case_N.h" switch_step++; if (am_server && code) msleep(100); close_all(); /* FALLTHROUGH */ default: break; } exit(code); }
void block_io_flush( block_io *io ) { srl_log(DEBUG, "Forcing " ); if ( io->left != io->size ) io_flush(io); }
/** * Eventually calls exit(), passing @p code, therefore does not return. * * @param code one of the RERR_* codes from errcode.h. **/ void _exit_cleanup(int code, const char *file, int line) { int ocode = code; static int inside_cleanup = 0; if (inside_cleanup > 10) { /* prevent the occasional infinite recursion */ return; } inside_cleanup++; signal(SIGUSR1, SIG_IGN); signal(SIGUSR2, SIG_IGN); if (verbose > 3) { rprintf(FINFO,"_exit_cleanup(code=%d, file=%s, line=%d): entered\n", code, safe_fname(file), line); } if (cleanup_child_pid != -1) { int status; if (waitpid(cleanup_child_pid, &status, WNOHANG) == cleanup_child_pid) { status = WEXITSTATUS(status); if (status > code) code = status; } } if (cleanup_got_literal && cleanup_fname && keep_partial && handle_partial_dir(cleanup_new_fname, PDIR_CREATE)) { char *fname = cleanup_fname; cleanup_fname = NULL; if (cleanup_fd_r != -1) close(cleanup_fd_r); if (cleanup_fd_w != -1) { flush_write_file(cleanup_fd_w); close(cleanup_fd_w); } finish_transfer(cleanup_new_fname, fname, cleanup_file, 0, !partial_dir); } io_flush(FULL_FLUSH); if (cleanup_fname) do_unlink(cleanup_fname); if (code) kill_all(SIGUSR1); if (cleanup_pid && cleanup_pid == getpid()) { char *pidf = lp_pid_file(); if (pidf && *pidf) unlink(lp_pid_file()); } if (code == 0) { if (io_error & IOERR_DEL_LIMIT) code = RERR_DEL_LIMIT; if (io_error & IOERR_VANISHED) code = RERR_VANISHED; if (io_error & IOERR_GENERAL || log_got_error) code = RERR_PARTIAL; } if (code) log_exit(code, file, line); if (verbose > 2) { rprintf(FINFO,"_exit_cleanup(code=%d, file=%s, line=%d): about to call exit(%d)\n", ocode, safe_fname(file), line, code); } close_all(); exit(code); }