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