void DHCP::domain_name(const string &name) { add_option(option(DOMAIN_NAME, name.size(), (const uint8_t*)name.c_str())); }
/* mutt_ssl_starttls: Negotiate TLS over an already opened connection. * TODO: Merge this code better with ssl_socket_open. */ int mutt_ssl_starttls (CONNECTION* conn) { sslsockdata* ssldata; int maxbits; long ssl_options = 0; if (ssl_init()) goto bail; ssldata = (sslsockdata*) safe_calloc (1, sizeof (sslsockdata)); /* the ssl_use_xxx protocol options don't apply. We must use TLS in TLS. * * However, we need to be able to negotiate amongst various TLS versions, * which at present can only be done with the SSLv23_client_method; * TLSv1_client_method gives us explicitly TLSv1.0, not 1.1 or 1.2 (True as * of OpenSSL 1.0.1c) */ if (! (ssldata->ctx = SSL_CTX_new (SSLv23_client_method()))) { dprint (1, (debugfile, "mutt_ssl_starttls: Error allocating SSL_CTX\n")); goto bail_ssldata; } #ifdef SSL_OP_NO_TLSv1_2 if (!option(OPTTLSV1_2)) ssl_options |= SSL_OP_NO_TLSv1_2; #endif #ifdef SSL_OP_NO_TLSv1_1 if (!option(OPTTLSV1_1)) ssl_options |= SSL_OP_NO_TLSv1_1; #endif #ifdef SSL_OP_NO_TLSv1 if (!option(OPTTLSV1)) ssl_options |= SSL_OP_NO_TLSv1; #endif /* these are always set */ #ifdef SSL_OP_NO_SSLv3 ssl_options |= SSL_OP_NO_SSLv3; #endif #ifdef SSL_OP_NO_SSLv2 ssl_options |= SSL_OP_NO_SSLv2; #endif if (! SSL_CTX_set_options(ssldata->ctx, ssl_options)) { dprint(1, (debugfile, "mutt_ssl_starttls: Error setting options to %ld\n", ssl_options)); goto bail_ctx; } ssl_get_client_cert(ssldata, conn); if (! (ssldata->ssl = SSL_new (ssldata->ctx))) { dprint (1, (debugfile, "mutt_ssl_starttls: Error allocating SSL\n")); goto bail_ctx; } if (SSL_set_fd (ssldata->ssl, conn->fd) != 1) { dprint (1, (debugfile, "mutt_ssl_starttls: Error setting fd\n")); goto bail_ssl; } if (ssl_negotiate (conn, ssldata)) goto bail_ssl; ssldata->isopen = 1; /* hmm. watch out if we're starting TLS over any method other than raw. */ conn->sockdata = ssldata; conn->conn_read = ssl_socket_read; conn->conn_write = ssl_socket_write; conn->conn_close = tls_close; conn->ssf = SSL_CIPHER_get_bits (SSL_get_current_cipher (ssldata->ssl), &maxbits); return 0; bail_ssl: FREE (&ssldata->ssl); bail_ctx: FREE (&ssldata->ctx); bail_ssldata: FREE (&ssldata); bail: return -1; }
/*! Returns true if the address of this socket can be used by other sockets at the same time, and false if this socket claims exclusive ownership. \sa setAddressReusable() */ bool Q3SocketDevice::addressReusable() const { return option( ReuseAddress ); }
int main(void) { ALLEGRO_DISPLAY *display; ALLEGRO_FONT *font; ALLEGRO_CONFIG *config; ALLEGRO_EVENT_QUEUE *queue; bool write = false; bool flip = false; bool quit; if (!al_init()) { abort_example("Could not init Allegro.\n"); } al_init_font_addon(); al_init_image_addon(); al_install_keyboard(); al_install_mouse(); /* Read parameters from ex_vsync.ini. */ config = al_load_config_file("ex_vsync.ini"); if (!config) { config = al_create_config(); write = true; } /* 0 -> Driver chooses. * 1 -> Force vsync on. * 2 -> Force vsync off. */ vsync = option(config, "vsync", 0); fullscreen = option(config, "fullscreen", 0); frequency = option(config, "frequency", 0); /* Write the file back (so a template is generated on first run). */ if (write) { al_save_config_file("ex_vsync.ini", config); } al_destroy_config(config); /* Vsync 1 means force on, 2 means forced off. */ if (vsync) al_set_new_display_option(ALLEGRO_VSYNC, vsync, ALLEGRO_SUGGEST); /* Force fullscreen mode. */ if (fullscreen) { al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW); /* Set a monitor frequency. */ if (frequency) al_set_new_display_refresh_rate(frequency); } display = al_create_display(640, 480); if (!display) { abort_example("Error creating display.\n"); } font = al_load_font("data/a4_font.tga", 0, 0); if (!font) { abort_example("Failed to load a4_font.tga\n"); } queue = al_create_event_queue(); al_register_event_source(queue, al_get_keyboard_event_source()); al_register_event_source(queue, al_get_mouse_event_source()); al_register_event_source(queue, al_get_display_event_source(display)); quit = display_warning(queue, font); al_flush_event_queue(queue); while (!quit) { ALLEGRO_EVENT event; /* With vsync, this will appear as a 50% gray screen (maybe * flickering a bit depending on monitor frequency). * Without vsync, there will be black/white shearing all over. */ if (flip) al_clear_to_color(al_map_rgb_f(1, 1, 1)); else al_clear_to_color(al_map_rgb_f(0, 0, 0)); al_flip_display(); flip = !flip; while (al_get_next_event(queue, &event)) { switch (event.type) { case ALLEGRO_EVENT_DISPLAY_CLOSE: quit = true; case ALLEGRO_EVENT_KEY_DOWN: if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE) quit = true; } } /* Let's not go overboard and limit flipping at 1000 Hz. Without * this my system locks up and requires a hard reboot :P */ al_rest(0.001); } al_destroy_font(font); al_destroy_event_queue(queue); return 0; }
/* return values: * * 1 message should be postponed * 0 normal exit * -1 abort message */ int mutt_compose_menu (HEADER *msg, /* structure for new message */ char *fcc, /* where to save a copy of the message */ size_t fcclen, HEADER *cur) /* current message */ { char helpstr[SHORT_STRING]; char buf[LONG_STRING]; char fname[_POSIX_PATH_MAX]; MUTTMENU *menu; ATTACHPTR **idx = NULL; short idxlen = 0; short idxmax = 0; int i, close = 0; int r = -1; /* return value */ int op = 0; int loop = 1; int fccSet = 0; /* has the user edited the Fcc: field ? */ CONTEXT *ctx = NULL, *this = NULL; /* Sort, SortAux could be changed in mutt_index_menu() */ int oldSort, oldSortAux; struct stat st; idx = mutt_gen_attach_list (msg->content, -1, idx, &idxlen, &idxmax, 0, 1); menu = mutt_new_menu (); menu->menu = MENU_COMPOSE; menu->offset = HDR_ATTACH; menu->max = idxlen; menu->make_entry = snd_entry; menu->tag = mutt_tag_attach; menu->title = _("Compose"); menu->data = idx; menu->help = mutt_compile_help (helpstr, sizeof (helpstr), MENU_COMPOSE, ComposeHelp); while (loop) { switch (op = mutt_menuLoop (menu)) { case OP_REDRAW: menu_redraw_status (menu); draw_envelope (msg, fcc); menu->offset = HDR_ATTACH; menu->pagelen = LINES - HDR_ATTACH - 2; break; case OP_COMPOSE_EDIT_FROM: menu->redraw = edit_address_list (HDR_FROM, &msg->env->from); break; case OP_COMPOSE_EDIT_TO: menu->redraw = edit_address_list (HDR_TO, &msg->env->to); break; case OP_COMPOSE_EDIT_BCC: menu->redraw = edit_address_list (HDR_BCC, &msg->env->bcc); break; case OP_COMPOSE_EDIT_CC: menu->redraw = edit_address_list (HDR_CC, &msg->env->cc); break; case OP_COMPOSE_EDIT_SUBJECT: if (msg->env->subject) strfcpy (buf, msg->env->subject, sizeof (buf)); else buf[0] = 0; if (mutt_get_field ("Subject: ", buf, sizeof (buf), 0) == 0) { mutt_str_replace (&msg->env->subject, buf); move (HDR_SUBJECT, HDR_XOFFSET); clrtoeol (); if (msg->env->subject) printw ("%-*.*s", W, W, msg->env->subject); } break; case OP_COMPOSE_EDIT_REPLY_TO: menu->redraw = edit_address_list (HDR_REPLYTO, &msg->env->reply_to); break; case OP_COMPOSE_EDIT_FCC: strfcpy (buf, fcc, sizeof (buf)); if (mutt_get_field ("Fcc: ", buf, sizeof (buf), M_FILE | M_CLEAR) == 0) { strfcpy (fcc, buf, _POSIX_PATH_MAX); mutt_pretty_mailbox (fcc); mvprintw (HDR_FCC, HDR_XOFFSET, "%-*.*s", W, W, fcc); fccSet = 1; } MAYBE_REDRAW (menu->redraw); break; case OP_COMPOSE_EDIT_MESSAGE: if (Editor && (mutt_strcmp ("builtin", Editor) != 0) && !option (OPTEDITHDRS)) { mutt_edit_file (Editor, msg->content->filename); mutt_update_encoding (msg->content); menu->redraw = REDRAW_CURRENT; break; } /* fall through */ case OP_COMPOSE_EDIT_HEADERS: if (op == OP_COMPOSE_EDIT_HEADERS || (op == OP_COMPOSE_EDIT_MESSAGE && option (OPTEDITHDRS))) { mutt_edit_headers ((!Editor || mutt_strcmp ("builtin", Editor) == 0) ? NONULL(Visual) : NONULL(Editor), msg->content->filename, msg, fcc, fcclen); } else { /* this is grouped with OP_COMPOSE_EDIT_HEADERS because the attachment list could change if the user invokes ~v to edit the message with headers, in which we need to execute the code below to regenerate the index array */ mutt_builtin_editor (msg->content->filename, msg, cur); } mutt_update_encoding (msg->content); /* attachments may have been added */ if (idxlen && idx[idxlen - 1]->content->next) { for (i = 0; i < idxlen; i++) safe_free ((void **) &idx[i]); idxlen = 0; idx = mutt_gen_attach_list (msg->content, -1, idx, &idxlen, &idxmax, 0, 1); menu->data = idx; menu->max = idxlen; } menu->redraw = REDRAW_FULL; break; #ifdef HAVE_PGP case OP_COMPOSE_ATTACH_KEY: if (idxlen == idxmax) { safe_realloc ((void **) &idx, sizeof (ATTACHPTR *) * (idxmax += 5)); menu->data = idx; } idx[idxlen] = (ATTACHPTR *) safe_calloc (1, sizeof (ATTACHPTR)); if ((idx[idxlen]->content = pgp_make_key_attachment(NULL)) != NULL) { idx[idxlen]->level = (idxlen > 0) ? idx[idxlen-1]->level : 0; if(idxlen) idx[idxlen - 1]->content->next = idx[idxlen]->content; menu->current = idxlen++; mutt_update_tree (idx, idxlen); menu->max = idxlen; menu->redraw |= REDRAW_INDEX; } else safe_free ((void **) &idx[idxlen]); menu->redraw |= REDRAW_STATUS; if(option(OPTNEEDREDRAW)) { menu->redraw = REDRAW_FULL; unset_option(OPTNEEDREDRAW); } break; #endif case OP_COMPOSE_ATTACH_FILE: { char *prompt, **files; int error, numfiles; fname[0] = 0; prompt = _("Attach file"); numfiles = 0; files = NULL; if (_mutt_enter_fname (prompt, fname, sizeof (fname), &menu->redraw, 0, 1, &files, &numfiles) == -1 || *fname == '\0') break; if (idxlen + numfiles >= idxmax) { safe_realloc ((void **) &idx, sizeof (ATTACHPTR *) * (idxmax += 5 + numfiles)); menu->data = idx; } error = 0; if (numfiles > 1) mutt_message _("Attaching selected files..."); for (i = 0; i < numfiles; i++) { char *att = files[i]; idx[idxlen] = (ATTACHPTR *) safe_calloc (1, sizeof (ATTACHPTR)); idx[idxlen]->content = mutt_make_file_attach (att); if (idx[idxlen]->content != NULL) update_idx (menu, idx, idxlen++); else { error = 1; mutt_error (_("Unable to attach %s!"), att); safe_free ((void **) &idx[idxlen]); } } FREE (&files); if (!error) mutt_clear_error (); menu->redraw |= REDRAW_INDEX | REDRAW_STATUS; } break; case OP_COMPOSE_ATTACH_MESSAGE: { char *prompt; HEADER *h; fname[0] = 0; prompt = _("Open mailbox to attach message from"); if (Context) { strfcpy (fname, NONULL (Context->path), sizeof (fname)); mutt_pretty_mailbox (fname); } if (mutt_enter_fname (prompt, fname, sizeof (fname), &menu->redraw, 1) == -1 || !fname[0]) break; mutt_expand_path (fname, sizeof (fname)); #ifdef USE_IMAP if (!mx_is_imap (fname)) #endif /* check to make sure the file exists and is readable */ if (access (fname, R_OK) == -1) { mutt_perror (fname); break; } menu->redraw = REDRAW_FULL; ctx = mx_open_mailbox (fname, M_READONLY, NULL); if (ctx == NULL) { mutt_perror (fname); break; } if (!ctx->msgcount) { mx_close_mailbox (ctx, NULL); safe_free ((void **) &ctx); mutt_error _("No messages in that folder."); break; } this = Context; /* remember current folder and sort methods*/ oldSort = Sort; oldSortAux = SortAux; Context = ctx; set_option(OPTATTACHMSG); mutt_message _("Tag the messages you want to attach!"); close = mutt_index_menu (); unset_option(OPTATTACHMSG); if (!Context) { /* go back to the folder we started from */ Context = this; /* Restore old $sort and $sort_aux */ Sort = oldSort; SortAux = oldSortAux; menu->redraw |= REDRAW_INDEX | REDRAW_STATUS; break; } if (idxlen + Context->tagged >= idxmax) { safe_realloc ((void **) &idx, sizeof (ATTACHPTR *) * (idxmax += 5 + Context->tagged)); menu->data = idx; } for (i = 0; i < Context->msgcount; i++) { h = Context->hdrs[i]; if (h->tagged) { idx[idxlen] = (ATTACHPTR *) safe_calloc (1, sizeof (ATTACHPTR)); idx[idxlen]->content = mutt_make_message_attach (Context, h, 1); if (idx[idxlen]->content != NULL) update_idx (menu, idx, idxlen++); else { mutt_error _("Unable to attach!"); safe_free ((void **) &idx[idxlen]); } } } menu->redraw |= REDRAW_FULL; if (close == OP_QUIT) mx_close_mailbox (Context, NULL); else mx_fastclose_mailbox (Context); safe_free ((void **) &Context); /* go back to the folder we started from */ Context = this; /* Restore old $sort and $sort_aux */ Sort = oldSort; SortAux = oldSortAux; } break; case OP_DELETE: CHECK_COUNT; if (delete_attachment (menu, &idxlen, menu->current) == -1) break; mutt_update_tree (idx, idxlen); if (idxlen) { if (menu->current > idxlen - 1) menu->current = idxlen - 1; } else menu->current = 0; if (menu->current == 0) msg->content = idx[0]->content; break; case OP_COMPOSE_CHANGE_CHARSET: CHECK_COUNT; menu->redraw = change_attachment_charset(idx[menu->current]->content); break; #define CURRENT idx[menu->current]->content case OP_COMPOSE_TOGGLE_RECODE: { CHECK_COUNT; if (!mutt_is_text_type (CURRENT->type, CURRENT->subtype)) { mutt_error (_("Recoding only affects text attachments.")); break; } if (mutt_is_utf8 (mutt_get_parameter ("charset", CURRENT->parameter))) { mutt_error (_("We currently can't encode to utf-8.")); break; } CURRENT->noconv = !CURRENT->noconv; if (CURRENT->noconv) mutt_message (_("The current attachment won't be converted.")); else mutt_message (_("The current attachment will be converted.")); menu->redraw = REDRAW_CURRENT; break; } case OP_COMPOSE_RECODE: { const char *chs; int rv; CHECK_COUNT; if (!mutt_is_text_type (CURRENT->type, CURRENT->subtype)) { mutt_error (_("Recoding only affects text attachments.")); break; } if (!(chs = mutt_get_parameter ("charset", CURRENT->parameter))) chs = SendCharset; if (CURRENT->noconv) rv = mutt_recode_file (CURRENT->filename, chs, Charset); else rv = mutt_recode_file (CURRENT->filename, Charset, chs); mutt_update_encoding (CURRENT); if (rv == 0) { mutt_message (_("Recoding successful.")); CURRENT->noconv = !CURRENT->noconv; } menu->redraw = REDRAW_CURRENT; break; } #undef CURRENT case OP_COMPOSE_EDIT_DESCRIPTION: CHECK_COUNT; strfcpy (buf, idx[menu->current]->content->description ? idx[menu->current]->content->description : "", sizeof (buf)); /* header names should not be translated */ if (mutt_get_field ("Description: ", buf, sizeof (buf), 0) == 0) { mutt_str_replace (&idx[menu->current]->content->description, buf); menu->redraw = REDRAW_CURRENT; } break; case OP_COMPOSE_UPDATE_ENCODING: CHECK_COUNT; if(menu->tagprefix) { BODY *top; for(top = msg->content; top; top = top->next) { if(top->tagged) mutt_update_encoding(top); } menu->redraw = REDRAW_FULL; } else { mutt_update_encoding(idx[menu->current]->content); menu->redraw = REDRAW_CURRENT; } break; case OP_COMPOSE_TOGGLE_DISPOSITION: /* toggle the content-disposition between inline/attachment */ idx[menu->current]->content->disposition = (idx[menu->current]->content->disposition == DISPINLINE) ? DISPATTACH : DISPINLINE; menu->redraw = REDRAW_CURRENT; break; case OP_EDIT_TYPE: CHECK_COUNT; { mutt_edit_content_type (NULL, idx[menu->current]->content); /* this may have been a change to text/something */ mutt_update_encoding (idx[menu->current]->content); menu->redraw = REDRAW_CURRENT; } break; case OP_COMPOSE_EDIT_ENCODING: CHECK_COUNT; strfcpy (buf, ENCODING (idx[menu->current]->content->encoding), sizeof (buf)); if (mutt_get_field ("Content-Transfer-Encoding: ", buf, sizeof (buf), 0) == 0 && buf[0]) { if ((i = mutt_check_encoding (buf)) != ENCOTHER && i != ENCUUENCODED) { idx[menu->current]->content->encoding = i; menu->redraw = REDRAW_CURRENT; mutt_clear_error(); } else mutt_error _("Invalid encoding."); } break; case OP_COMPOSE_SEND_MESSAGE: if(check_attachments(idx, idxlen) != 0) { menu->redraw = REDRAW_FULL; break; } #ifdef MIXMASTER if (msg->chain && mix_check_message (msg) != 0) break; #endif if (!fccSet && *fcc) { if ((i = query_quadoption (OPT_COPY, _("Save a copy of this message?"))) == -1) break; else if (i == M_NO) *fcc = 0; } loop = 0; r = 0; break; case OP_COMPOSE_EDIT_FILE: CHECK_COUNT; mutt_edit_file ((!Editor || mutt_strcmp ("builtin", Editor) == 0) ? NONULL(Visual) : NONULL(Editor), idx[menu->current]->content->filename); mutt_update_encoding (idx[menu->current]->content); menu->redraw = REDRAW_CURRENT; break; case OP_COMPOSE_TOGGLE_UNLINK: CHECK_COUNT; idx[menu->current]->content->unlink = !idx[menu->current]->content->unlink; #if 0 /* OPTRESOLVE is otherwise ignored on this menu. * Where's the bug? */ if (option (OPTRESOLVE) && menu->current + 1 < menu->max) menu->current++; # endif menu->redraw = REDRAW_INDEX; break; case OP_COMPOSE_GET_ATTACHMENT: CHECK_COUNT; if(menu->tagprefix) { BODY *top; for(top = msg->content; top; top = top->next) { if(top->tagged) mutt_get_tmp_attachment(top); } menu->redraw = REDRAW_FULL; } else if (mutt_get_tmp_attachment(idx[menu->current]->content) == 0) menu->redraw = REDRAW_CURRENT; break; case OP_COMPOSE_RENAME_FILE: CHECK_COUNT; strfcpy (fname, idx[menu->current]->content->filename, sizeof (fname)); mutt_pretty_mailbox (fname); if (mutt_get_field (_("Rename to: "), fname, sizeof (fname), M_FILE) == 0 && fname[0]) { if(stat(idx[menu->current]->content->filename, &st) == -1) { mutt_error (_("Can't stat: %s"), fname); break; } mutt_expand_path (fname, sizeof (fname)); if(mutt_rename_file (idx[menu->current]->content->filename, fname)) break; mutt_str_replace (&idx[menu->current]->content->filename, fname); menu->redraw = REDRAW_CURRENT; if(idx[menu->current]->content->stamp >= st.st_mtime) mutt_stamp_attachment(idx[menu->current]->content); } break; case OP_COMPOSE_NEW_MIME: { char type[STRING]; char *p; int itype; FILE *fp; CLEARLINE (LINES-1); fname[0] = 0; if (mutt_get_field (_("New file: "), fname, sizeof (fname), M_FILE) != 0 || !fname[0]) continue; mutt_expand_path (fname, sizeof (fname)); /* Call to lookup_mime_type () ? maybe later */ type[0] = 0; if (mutt_get_field ("Content-Type: ", type, sizeof (type), 0) != 0 || !type[0]) continue; if (!(p = strchr (type, '/'))) { mutt_error _("Content-Type is of the form base/sub"); continue; } *p++ = 0; if ((itype = mutt_check_mime_type (type)) == TYPEOTHER) { mutt_error (_("Unknown Content-Type %s"), type); continue; } if (idxlen == idxmax) { safe_realloc ((void **) &idx, sizeof (ATTACHPTR *) * (idxmax += 5)); menu->data = idx; } idx[idxlen] = (ATTACHPTR *) safe_calloc (1, sizeof (ATTACHPTR)); /* Touch the file */ if (!(fp = safe_fopen (fname, "w"))) { mutt_error (_("Can't create file %s"), fname); safe_free ((void **) &idx[idxlen]); continue; } fclose (fp); if ((idx[idxlen]->content = mutt_make_file_attach (fname)) == NULL) { mutt_error _("What we have here is a failure to make an attachment"); continue; } idx[idxlen]->level = (idxlen > 0) ? idx[idxlen-1]->level : 0; if (idxlen) idx[idxlen - 1]->content->next = idx[idxlen]->content; menu->current = idxlen++; mutt_update_tree (idx, idxlen); menu->max = idxlen; idx[menu->current]->content->type = itype; mutt_str_replace (&idx[menu->current]->content->subtype, p); idx[menu->current]->content->unlink = 1; menu->redraw |= REDRAW_INDEX | REDRAW_STATUS; if (mutt_compose_attachment (idx[menu->current]->content)) { mutt_update_encoding (idx[menu->current]->content); menu->redraw = REDRAW_FULL; } } break; case OP_COMPOSE_EDIT_MIME: CHECK_COUNT; if (mutt_edit_attachment (idx[menu->current]->content)) { mutt_update_encoding (idx[menu->current]->content); menu->redraw = REDRAW_FULL; } break; case OP_VIEW_ATTACH: case OP_DISPLAY_HEADERS: CHECK_COUNT; mutt_attach_display_loop (menu, op, NULL, NULL, idx, idxlen); menu->redraw = REDRAW_FULL; break; case OP_SAVE: CHECK_COUNT; mutt_save_attachment_list (NULL, menu->tagprefix, menu->tagprefix ? msg->content : idx[menu->current]->content, NULL); MAYBE_REDRAW (menu->redraw); break; case OP_PRINT: CHECK_COUNT; mutt_print_attachment_list (NULL, menu->tagprefix, menu->tagprefix ? msg->content : idx[menu->current]->content); break; case OP_PIPE: case OP_FILTER: CHECK_COUNT; mutt_pipe_attachment_list (NULL, menu->tagprefix, menu->tagprefix ? msg->content : idx[menu->current]->content, op == OP_FILTER); if (op == OP_FILTER) /* cte might have changed */ menu->redraw = menu->tagprefix ? REDRAW_FULL : REDRAW_CURRENT; break; case OP_EXIT: if ((i = query_quadoption (OPT_POSTPONE, _("Postpone this message?"))) == M_NO) { while (idxlen-- > 0) { /* avoid freeing other attachments */ idx[idxlen]->content->next = NULL; idx[idxlen]->content->parts = NULL; mutt_free_body (&idx[idxlen]->content); safe_free ((void **) &idx[idxlen]->tree); safe_free ((void **) &idx[idxlen]); } safe_free ((void **) &idx); idxlen = 0; idxmax = 0; r = -1; loop = 0; break; } else if (i == -1) break; /* abort */ /* fall through to postpone! */ case OP_COMPOSE_POSTPONE_MESSAGE: if(check_attachments(idx, idxlen) != 0) { menu->redraw = REDRAW_FULL; break; } loop = 0; r = 1; break; case OP_COMPOSE_ISPELL: endwin (); snprintf (buf, sizeof (buf), "%s -x %s", NONULL(Ispell), msg->content->filename); if (mutt_system (buf) == -1) mutt_error (_("Error running \"%s\"!"), buf); else mutt_update_encoding (msg->content); break; case OP_COMPOSE_WRITE_MESSAGE: fname[0] = '\0'; if (Context) { strfcpy (fname, NONULL (Context->path), sizeof (fname)); mutt_pretty_mailbox (fname); } if (idxlen) msg->content = idx[0]->content; if (mutt_enter_fname (_("Write message to mailbox"), fname, sizeof (fname), &menu->redraw, 1) != -1 && fname[0]) { mutt_message (_("Writing message to %s ..."), fname); mutt_expand_path (fname, sizeof (fname)); if (msg->content->next) msg->content = mutt_make_multipart (msg->content); if (mutt_write_fcc (NONULL (fname), msg, NULL, 1, NULL) < 0) msg->content = mutt_remove_multipart (msg->content); else mutt_message _("Message written."); } break; #ifdef HAVE_PGP case OP_COMPOSE_PGP_MENU: msg->pgp = pgp_send_menu (msg->pgp, &menu->redraw); break; case OP_FORGET_PASSPHRASE: mutt_forget_passphrase (); break; #endif /* HAVE_PGP */ #ifdef MIXMASTER case OP_COMPOSE_MIX: mix_make_chain (&msg->chain, &menu->redraw); break; #endif } } mutt_menuDestroy (&menu); if (idxlen) { msg->content = idx[0]->content; for (i = 0; i < idxlen; i++) safe_free ((void **) &idx[i]); } else msg->content = NULL; safe_free ((void **) &idx); return (r); }
/* parse command line & set command arguments. returns the index of * non-option arguments, -1 if there is an error. */ int parse_args(char **argv, int what, /* OF_CMDLINE or OF_SET */ int *setargsp) { static char cmd_opts[NELEM(options) + 3]; /* o:\0 */ static char set_opts[NELEM(options) + 5]; /* Ao;s\0 */ char *opts; char *array = (char *) 0; Getopt go; int i, optc, set, sortargs = 0, arrayset = 0; /* First call? Build option strings... */ if (cmd_opts[0] == '\0') { char *p, *q; /* see cmd_opts[] declaration */ strlcpy(cmd_opts, "o:", sizeof cmd_opts); p = cmd_opts + strlen(cmd_opts); /* see set_opts[] declaration */ strlcpy(set_opts, "A:o;s", sizeof set_opts); q = set_opts + strlen(set_opts); for (i = 0; i < NELEM(options); i++) { if (options[i].c) { if (options[i].flags & OF_CMDLINE) *p++ = options[i].c; if (options[i].flags & OF_SET) *q++ = options[i].c; } } *p = '\0'; *q = '\0'; } if (what == OF_CMDLINE) { char *p; /* Set FLOGIN before parsing options so user can clear * flag using +l. */ Flag(FLOGIN) = (argv[0][0] == '-' || ((p = strrchr(argv[0], '/')) && *++p == '-')); opts = cmd_opts; } else opts = set_opts; ksh_getopt_reset(&go, GF_ERROR|GF_PLUSOPT); while ((optc = ksh_getopt(argv, &go, opts)) != -1) { set = (go.info & GI_PLUS) ? 0 : 1; switch (optc) { case 'A': arrayset = set ? 1 : -1; array = go.optarg; break; case 'o': if (go.optarg == (char *) 0) { /* lone -o: print options * * Note that on the command line, -o requires * an option (ie, can't get here if what is * OF_CMDLINE). */ printoptions(set); break; } i = option(go.optarg); if (i >= 0 && set == Flag(i)) /* Don't check the context if the flag * isn't changing - makes "set -o interactive" * work if you're already interactive. Needed * if the output of "set +o" is to be used. */ ; else if (i >= 0 && (options[i].flags & what)) change_flag((enum sh_flag) i, what, set); else { bi_errorf("%s: bad option", go.optarg); return -1; } break; case '?': return -1; default: /* -s: sort positional params (at&t ksh stupidity) */ if (what == OF_SET && optc == 's') { sortargs = 1; break; } for (i = 0; i < NELEM(options); i++) if (optc == options[i].c && (what & options[i].flags)) { change_flag((enum sh_flag) i, what, set); break; } if (i == NELEM(options)) { internal_errorf(1, "parse_args: `%c'", optc); return -1; /* not reached */ } } } if (!(go.info & GI_MINUSMINUS) && argv[go.optind] && (argv[go.optind][0] == '-' || argv[go.optind][0] == '+') && argv[go.optind][1] == '\0') { /* lone - clears -v and -x flags */ if (argv[go.optind][0] == '-' && !Flag(FPOSIX)) Flag(FVERBOSE) = Flag(FXTRACE) = 0; /* set skips lone - or + option */ go.optind++; } if (setargsp) /* -- means set $#/$* even if there are no arguments */ *setargsp = !arrayset && ((go.info & GI_MINUSMINUS) || argv[go.optind]); if (arrayset && (!*array || *skip_varname(array, false))) { bi_errorf("%s: is not an identifier", array); return -1; } if (sortargs) { for (i = go.optind; argv[i]; i++) ; qsortp((void **) &argv[go.optind], (size_t) (i - go.optind), xstrcmp); } if (arrayset) { set_array(array, arrayset, argv + go.optind); for (; argv[go.optind]; go.optind++) ; } return go.optind; }
Message::Message(SQLite3DB::DB *db):IDatabase(db),m_nntpmessageid(-1) { Option option(db); option.GetBool("UniqueBoardMessageIDs",m_uniqueboardmessageids); Initialize(); }
/*! Returns true if this socket has the keepalive option set. \sa setKeepalive() */ bool MSocketDevice::keepalive() const { return option(Keepalive); }
/*! Returns the size of the operating system send buffer. \sa setSendBufferSize() */ int MSocketDevice::sendBufferSize() const { return option(SendBuffer); }
void Message::unpack(const QByteArray &packed) { d->errors = MessagePrivate::Errors(0); d->options.clear(); quint8 *p = (quint8 *)packed.data(); quint8 *pend = (quint8 *)packed.data() + packed.size() - 1; if (packed.size() < 4) { d->errors |= MessagePrivate::FORMAT_ERROR; return; } d->version = (p[0] & 0xc0) >> 6; if (d->version != 1) d->errors |= MessagePrivate::UNKNOWN_VERSION; d->type = (Message::Type)( (p[0] & 0x30) >> 4 ); quint8 tokenLength = (p[0] & 0xf); d->code = (Message::Code)p[1]; if (tokenLength > 8) d->errors |= MessagePrivate::WRONG_TOKEN_LENGTH; else d->token = QByteArray((const char *)p + 4, tokenLength); d->message_id = endian_load16(quint16, (p + 2)); if (packed.size() == 4) // only header present, ok return; p += tokenLength; p += 4; quint16 optionNumber = 0; do { if (*p == 0xff) { quint32 payloadSize = pend - p; if (payloadSize == 0) d->errors |= MessagePrivate::WRONG_PAYLOAD_MARKER; d->payload = QByteArray((const char *)p + 1, payloadSize); return; } quint16 optionDelta = (*p & 0xf0) >> 4; quint16 optionLength = (*p & 0xf); p++; if (optionDelta == 13) { optionDelta = *p + 13; p++; } else if (optionDelta == 14) { optionDelta = endian_load16(quint16, p); p += 2; } else if (optionDelta == 15) { d->errors |= MessagePrivate::WRONG_PAYLOAD_MARKER; return; } if (optionLength == 13) { optionLength = *p + 13; p++; } else if (optionLength == 14) { optionLength = endian_load16(quint16, p); p += 2; } else if (optionLength == 15) { d->errors |= MessagePrivate::WRONG_PAYLOAD_MARKER; return; } optionNumber += optionDelta; Option option((Message::OptionType)optionNumber, QByteArray((const char *)p, optionLength)); d->options.append(option); p += optionLength; } while (p <= pend); if (p > pend + 1) d->errors |= MessagePrivate::NOT_ENOUGH_DATA; }
/*! Returns true if this socket has the broadcast option set. \sa setBroadcast() */ bool MSocketDevice::broadcast() const { return option(Broadcast); }
void DHCP::type(Flags type) { uint8_t int_type = type; add_option(option(DHCP_MESSAGE_TYPE, sizeof(uint8_t), &int_type)); }
void DHCP::rebind_time(uint32_t time) { time = Endian::host_to_be(time); add_option(option(DHCP_REBINDING_TIME, sizeof(uint32_t), (uint8_t*)&time)); }
void DHCP::hostname(const std::string &name) { add_option(option(HOST_NAME, name.size(), (const uint8_t*)name.c_str())); }
static ADDRESS *mutt_expand_aliases_r (ADDRESS *a, LIST **expn) { ADDRESS *head = NULL, *last = NULL, *t, *w; LIST *u; char i; const char *fqdn; while (a) { if (!a->group && !a->personal && a->mailbox && strchr (a->mailbox, '@') == NULL) { t = mutt_lookup_alias (a->mailbox); if (t) { i = 0; for (u = *expn; u; u = u->next) { if (mutt_strcmp (a->mailbox, u->data) == 0) /* alias already found */ { dprint (1, (debugfile, "mutt_expand_aliases_r(): loop in alias found for '%s'\n", a->mailbox)); i = 1; break; } } if (!i) { u = safe_malloc (sizeof (LIST)); u->data = safe_strdup (a->mailbox); u->next = *expn; *expn = u; w = rfc822_cpy_adr (t, 0); w = mutt_expand_aliases_r (w, expn); if (head) last->next = w; else head = last = w; while (last && last->next) last = last->next; } t = a; a = a->next; t->next = NULL; rfc822_free_address (&t); continue; } else { struct passwd *pw = getpwnam (a->mailbox); if (pw) { char namebuf[STRING]; mutt_gecos_name (namebuf, sizeof (namebuf), pw); mutt_str_replace (&a->personal, namebuf); #ifdef EXACT_ADDRESS FREE (&a->val); #endif } } } if (head) { last->next = a; last = last->next; } else head = last = a; a = a->next; last->next = NULL; } if (option (OPTUSEDOMAIN) && (fqdn = mutt_fqdn(1))) { /* now qualify all local addresses */ rfc822_qualify (head, fqdn); } return (head); }
void LevelSetDelegate::paint(QPainter* p, const QStyleOptionViewItem& opt, const QModelIndex& index) const { p->save(); QStyleOptionViewItemV4 option(opt); initStyleOption(&option, index); // // Draw item with no textwith a decoration and selection (if it's selected) // // we want to paint text by ourselves, so set it to null, paint selection and then paint text QString text = index.data(Qt::DisplayRole).toString(); option.text = QString(); option.decorationSize = QSize(48, 48); QStyle* style = QApplication::style(); style->drawControl(QStyle::CE_ItemViewItem, &option, p, 0); if (option.state & QStyle::State_Selected) p->setPen(option.palette.color(QPalette::Normal, QPalette::HighlightedText)); else p->setPen(option.palette.color(QPalette::Normal, QPalette::Text)); // // Draw text // int marginH = style->pixelMetric( QStyle::PM_FocusFrameHMargin ); int marginV = style->pixelMetric( QStyle::PM_FocusFrameVMargin ); int innerSpacing = 9; int textStartX = option.decorationSize.width() + innerSpacing; QRect r = opt.rect.adjusted(textStartX, marginV*2, 0, 0); QFontMetrics fm(opt.font); int flags = Qt::AlignLeft | Qt::AlignTop | Qt::TextSingleLine; QFont font = p->font(); font.setBold(true); p->setFont(font); p->drawText(r, flags, text); // // Draw Author name // QString authorName = index.data(KAtomic::LevelSetAuthorRole).toString(); if (!authorName.isEmpty()) { if (option.state & QStyle::State_Selected) p->setPen(option.palette.color(QPalette::Disabled, QPalette::HighlightedText)); else p->setPen(option.palette.color(QPalette::Disabled, QPalette::Text)); r = r.adjusted(innerSpacing, fm.lineSpacing(), -marginH*2, 0); flags = Qt::AlignLeft | Qt::AlignTop; p->setFont(QFontDatabase::systemFont(QFontDatabase::SmallestReadableFont)); QString text = i18n("by %1", authorName); QString authorEmail = index.data(KAtomic::LevelSetAuthorEmailRole).toString(); if (!authorEmail.isEmpty()) text.append(QStringLiteral(" <%1>").arg(authorEmail)); int numLevels = index.data(KAtomic::LevelSetLevelCountRole).toUInt(); text.append(i18np(", contains 1 level", ", contains %1 levels", numLevels)); p->drawText(r, flags, text); } // // Draw description // QString descr = index.data(KAtomic::LevelSetDescriptionRole).toString(); if (!descr.isEmpty()) { if (option.state & QStyle::State_Selected) p->setPen(option.palette.color(QPalette::Normal, QPalette::HighlightedText)); else p->setPen(option.palette.color(QPalette::Normal, QPalette::Text)); r = opt.rect.adjusted(textStartX, fm.lineSpacing()*2, -marginH*2, -marginV*2); flags = Qt::AlignLeft | Qt::AlignBottom | Qt::TextSingleLine; p->setFont(opt.font); QString elided = fm.elidedText(descr, Qt::ElideMiddle, r.width(), flags); p->drawText(r, flags, descr); } p->restore(); }
Grid::Grid(char *fname){ register int i,j; char buf[BUFSIZ]; if(option("REAFILE")){ register int k,l; int dim; double **xloc, **yloc, **zloc; int **locvid; sprintf(buf, "%s.rea",strtok(fname,"\n")); domainname = strdup(buf); domainfile = fopen(domainname,"r"); if(!findSection("MESH",buf,domainfile)) {fputs("Grid_rea: Section not found\n", stderr); exit(-1);} get_next_line(domainfile, buf); sscanf(buf,"%d%d",&nel,&dim); if(dim != 3){ fputs("Grid_rea: Mesh is not 3D\n",stderr); exit(-1);} xloc = dmatrix(0,nel-1,0,Max_Nverts-1); yloc = dmatrix(0,nel-1,0,Max_Nverts-1); zloc = dmatrix(0,nel-1,0,Max_Nverts-1); nverts = ivector(0, nel-1); /* read local mesh */ for(k = 0; k < nel; k++) { get_next_line(domainfile, buf); /* element header */ if(strstr(buf,"Hex") || strstr(buf,"hex")){ fscanf(domainfile,"%lf%lf%lf%lf%lf%lf%lf%lf", xloc[k],xloc[k]+1,xloc[k]+2,xloc[k]+3,xloc[k]+4, xloc[k]+5,xloc[k]+6,xloc[k]+7); fscanf(domainfile,"%lf%lf%lf%lf%lf%lf%lf%lf", yloc[k],yloc[k]+1,yloc[k]+2,yloc[k]+3,yloc[k]+4, yloc[k]+5,yloc[k]+6,yloc[k]+7); fscanf(domainfile,"%lf%lf%lf%lf%lf%lf%lf%lf", zloc[k],zloc[k]+1,zloc[k]+2,zloc[k]+3,zloc[k]+4, zloc[k]+5,zloc[k]+6,zloc[k]+7); get_next_line(domainfile, buf); /* get remainder of line */ nverts[k] = 8; } else if(strstr(buf,"Prism") || strstr(buf,"prism")){ fscanf(domainfile,"%lf%lf%lf%lf%lf%lf", xloc[k],xloc[k]+1,xloc[k]+2,xloc[k]+3,xloc[k]+4,xloc[k]+5); fscanf(domainfile,"%lf%lf%lf%lf%lf%lf", yloc[k],yloc[k]+1,yloc[k]+2,yloc[k]+3,yloc[k]+4,yloc[k]+5); fscanf(domainfile,"%lf%lf%lf%lf%lf%lf", zloc[k],zloc[k]+1,zloc[k]+2,zloc[k]+3,zloc[k]+4,zloc[k]+5); get_next_line(domainfile, buf); /* get remainder of line */ nverts[k] = 6; } else if(strstr(buf,"Pyr") || strstr(buf,"pyr")){ fscanf(domainfile,"%lf%lf%lf%lf%lf", xloc[k],xloc[k]+1,xloc[k]+2,xloc[k]+3,xloc[k]+4); fscanf(domainfile,"%lf%lf%lf%lf%lf", yloc[k],yloc[k]+1,yloc[k]+2,yloc[k]+3,yloc[k]+4); fscanf(domainfile,"%lf%lf%lf%lf%lf", zloc[k],zloc[k]+1,zloc[k]+2,zloc[k]+3,zloc[k]+4); get_next_line(domainfile, buf); /* get remainder of line */ nverts[k] = 5; } else{ /* assume it is a tet */ fscanf(domainfile,"%lf%lf%lf%lf",xloc[k],xloc[k]+1,xloc[k]+2,xloc[k]+3); fscanf(domainfile,"%lf%lf%lf%lf",yloc[k],yloc[k]+1,yloc[k]+2,yloc[k]+3); fscanf(domainfile,"%lf%lf%lf%lf",zloc[k],zloc[k]+1,zloc[k]+2,zloc[k]+3); get_next_line(domainfile, buf); /* get remainder of line */ nverts[k] = 4; } } /* search through elements and search for similar elements */ vertids = imatrix(0,nel-1,0,Max_Nverts-1); ifill(nel*Max_Nverts,-1,vertids[0],1); totverts=0; for(k = 0; k < nel; ++k) for(i= 0; i < nverts[k]; ++i) if(vertids[k][i] == -1){ vertids[k][i] = totverts++; for(l = k+1; l < nel; ++l) for(j = 0; j < nverts[l]; ++j) if(vertids[l][j] == -1){ if(same(xloc[l][j],xloc[k][i]) && same(yloc[l][j],yloc[k][i]) && same(zloc[l][j],zloc[k][i])) vertids[l][j] = vertids[k][i]; } } xcoords = dvector(0, totverts-1); ycoords = dvector(0, totverts-1); zcoords = dvector(0, totverts-1); for(k = 0; k < nel; ++k) for(i= 0; i < nverts[k]; ++i){ xcoords[vertids[k][i]] = xloc[k][i]; ycoords[vertids[k][i]] = yloc[k][i]; zcoords[vertids[k][i]] = zloc[k][i]; } free_dmatrix(xloc,0,0); free_dmatrix(yloc,0,0); free_dmatrix(zloc,0,0); } else{ char language; sprintf(buf, strtok(fname, "\n")); domainname = strdup(buf); domainfile = fopen(domainname, "r"); get_next_line(domainfile, buf); sscanf(buf, "%c", &language); get_next_line(domainfile, buf); sscanf(buf, "%d", &totverts); xcoords = dvector(0, totverts-1); ycoords = dvector(0, totverts-1); zcoords = dvector(0, totverts-1); for(i=0;i<totverts;++i){ get_next_line(domainfile, buf); sscanf(buf, "%lf %lf %lf", xcoords+i, ycoords+i, zcoords+i); } get_next_line(domainfile, buf); sscanf(buf, "%d", &nel); nverts = ivector(0, nel-1); vertids = imatrix(0, nel-1, 0, Max_Nverts-1); ifill(nel*Max_Nverts, -1, vertids[0], 1); for(i=0;i<nel;++i){ get_next_line(domainfile, buf); sscanf(buf, "%d", nverts+i); switch(nverts[i]){ case 4: sscanf(buf, "%*d %d %d %d %d", vertids[i], vertids[i]+1, vertids[i]+2, vertids[i]+3); break; case 5: sscanf(buf, "%*d %d %d %d %d %d", vertids[i], vertids[i]+1, vertids[i]+2, vertids[i]+3, vertids[i]+4); break; case 6: sscanf(buf, "%*d %d %d %d %d %d %d", vertids[i], vertids[i]+1, vertids[i]+2, vertids[i]+3, vertids[i]+4, vertids[i]+5); break; case 8: sscanf(buf, "%*d %d %d %d %d %d %d %d %d", vertids[i], vertids[i]+1, vertids[i]+2, vertids[i]+3, vertids[i]+4, vertids[i]+5, vertids[i]+6, vertids[i]+7); break; } if(language == 'F'){ for(j=0;j<nverts[i];++j) vertids[i][j] -=1; } } } elmtids = ivector(0, nel-1); for(i=0;i<nel;++i) elmtids[i] = i; vertexmap = imatrix(0, nel-1, 0, Max_Nverts-1); ifill(nel*Max_Nverts, -1, vertexmap[0], 1); for(i=0;i<nel;++i) for(j=0;j<nverts[i];++j) vertexmap[i][j] = j; }
int main(int argc, char *argv[]) { int retval; R_RSA_PUBLIC_KEY key; char log_path[256]; #ifdef _USING_FCGI_ unsigned int counter=0; #endif for(int c = 1; c < argc; c++) { std::string option(argv[c]); if(option == "-v" || option == "--version") { printf("%s\n", SVN_VERSION); exit(0); } else if(option == "-h" || option == "--help") { usage(argv[0]); exit(0); } else if (option.length()){ fprintf(stderr, "unknown command line argument: %s\n\n", argv[c]); usage(argv[0]); exit(1); } } installer(); get_log_path(log_path, "file_upload_handler.log"); #ifndef _USING_FCGI_ if (!freopen(log_path, "a", stderr)) { fprintf(stderr, "Can't open log file '%s' (errno: %d)\n", log_path, errno ); return_error(ERR_TRANSIENT, "can't open log file '%s' (errno: %d)", log_path, errno ); exit(1); } #else FCGI_FILE *f = FCGI::fopen(log_path, "a"); if (f) { log_messages.redirect(f); } else { fprintf(stderr, "Can't redirect FCGI log messages\n"); return_error(ERR_TRANSIENT, "can't open log file (FCGI)"); exit(1); } #endif retval = config.parse_file(); if (retval) { fprintf(stderr, "Can't parse config.xml: %s\n", boincerror(retval)); return_error(ERR_TRANSIENT, "can't parse config file", log_path, errno ); exit(1); } log_messages.pid = getpid(); log_messages.set_debug_level(config.fuh_debug_level); if (boinc_file_exists(config.project_path("stop_upload"))) { return_error(ERR_TRANSIENT, "Maintenance underway: file uploads are temporarily disabled."); exit(1); } if (!config.ignore_upload_certificates) { retval = get_key(key); if (retval) { return_error(ERR_TRANSIENT, "can't read key file"); exit(1); } } #ifdef _USING_FCGI_ while(FCGI_Accept() >= 0) { counter++; //fprintf(stderr, "file_upload_handler (FCGI): counter: %d\n", counter); log_messages.set_indent_level(0); #endif handle_request(stdin, key); #ifdef _USING_FCGI_ // flush log for FCGI, otherwise it just buffers a lot log_messages.flush(); } // when exiting, write headers back to apache so it won't complain // about "incomplete headers" fprintf(stdout,"Content-type: text/plain\n\n"); #endif return 0; }
int _mutt_copy_message (FILE *fpout, FILE *fpin, HEADER *hdr, BODY *body, int flags, int chflags) { char prefix[SHORT_STRING]; STATE s; LOFF_T new_offset = -1; int rc = 0; if (flags & M_CM_PREFIX) { if (option (OPTTEXTFLOWED)) strfcpy (prefix, ">", sizeof (prefix)); else _mutt_make_string (prefix, sizeof (prefix), NONULL (Prefix), Context, hdr, 0); } if ((flags & M_CM_NOHEADER) == 0) { if (flags & M_CM_PREFIX) chflags |= CH_PREFIX; else if (hdr->attach_del && (chflags & CH_UPDATE_LEN)) { int new_lines; LOFF_T new_length = body->length; char date[SHORT_STRING]; mutt_make_date (date, sizeof (date)); date[5] = date[mutt_strlen (date) - 1] = '\"'; /* Count the number of lines and bytes to be deleted */ fseeko (fpin, body->offset, SEEK_SET); new_lines = hdr->lines - count_delete_lines (fpin, body, &new_length, mutt_strlen (date)); /* Copy the headers */ if (mutt_copy_header (fpin, hdr, fpout, chflags | CH_NOLEN | CH_NONEWLINE, NULL)) return -1; fprintf (fpout, "Content-Length: " OFF_T_FMT "\n", new_length); if (new_lines <= 0) new_lines = 0; else fprintf (fpout, "Lines: %d\n", new_lines); putc ('\n', fpout); if (ferror (fpout) || feof (fpout)) return -1; new_offset = ftello (fpout); /* Copy the body */ fseeko (fpin, body->offset, SEEK_SET); if (copy_delete_attach (body, fpin, fpout, date)) return -1; #ifdef DEBUG { LOFF_T fail = ((ftello (fpout) - new_offset) - new_length); if (fail) { mutt_error ("The length calculation was wrong by %ld bytes", fail); new_length += fail; mutt_sleep (1); } } #endif /* Update original message if we are sync'ing a mailfolder */ if (flags & M_CM_UPDATE) { hdr->attach_del = 0; hdr->lines = new_lines; body->offset = new_offset; /* update the total size of the mailbox to reflect this deletion */ Context->size -= body->length - new_length; /* * if the message is visible, update the visible size of the mailbox * as well. */ if (Context->v2r[hdr->msgno] != -1) Context->vsize -= body->length - new_length; body->length = new_length; mutt_free_body (&body->parts); } return 0; } if (mutt_copy_header (fpin, hdr, fpout, chflags, (chflags & CH_PREFIX) ? prefix : NULL) == -1) return -1; new_offset = ftello (fpout); } if (flags & M_CM_DECODE) { /* now make a text/plain version of the message */ memset (&s, 0, sizeof (STATE)); s.fpin = fpin; s.fpout = fpout; if (flags & M_CM_PREFIX) s.prefix = prefix; if (flags & M_CM_DISPLAY) s.flags |= M_DISPLAY; if (flags & M_CM_PRINTING) s.flags |= M_PRINTING; if (flags & M_CM_WEED) s.flags |= M_WEED; if (flags & M_CM_CHARCONV) s.flags |= M_CHARCONV; if (flags & M_CM_REPLYING) s.flags |= M_REPLYING; if (WithCrypto && flags & M_CM_VERIFY) s.flags |= M_VERIFY; rc = mutt_body_handler (body, &s); } else if (WithCrypto && (flags & M_CM_DECODE_CRYPT) && (hdr->security & ENCRYPT)) { BODY *cur = NULL; FILE *fp; if ((WithCrypto & APPLICATION_PGP) && (flags & M_CM_DECODE_PGP) && (hdr->security & APPLICATION_PGP) && hdr->content->type == TYPEMULTIPART) { if (crypt_pgp_decrypt_mime (fpin, &fp, hdr->content, &cur)) return (-1); fputs ("MIME-Version: 1.0\n", fpout); } if ((WithCrypto & APPLICATION_SMIME) && (flags & M_CM_DECODE_SMIME) && (hdr->security & APPLICATION_SMIME) && hdr->content->type == TYPEAPPLICATION) { if (crypt_smime_decrypt_mime (fpin, &fp, hdr->content, &cur)) return (-1); } if (!cur) { mutt_error (_("No decryption engine available for message")); return -1; } mutt_write_mime_header (cur, fpout); fputc ('\n', fpout); fseeko (fp, cur->offset, 0); if (mutt_copy_bytes (fp, fpout, cur->length) == -1) { safe_fclose (&fp); mutt_free_body (&cur); return (-1); } mutt_free_body (&cur); safe_fclose (&fp); } else { fseeko (fpin, body->offset, 0); if (flags & M_CM_PREFIX) { int c; size_t bytes = body->length; fputs(prefix, fpout); while((c = fgetc(fpin)) != EOF && bytes--) { fputc(c, fpout); if(c == '\n') { fputs(prefix, fpout); } } } else if (mutt_copy_bytes (fpin, fpout, body->length) == -1) return -1; } if ((flags & M_CM_UPDATE) && (flags & M_CM_NOHEADER) == 0 && new_offset != -1) { body->offset = new_offset; mutt_free_body (&body->parts); } return rc; }
int mutt_prepare_template (FILE * fp, CONTEXT * ctx, HEADER * newhdr, HEADER * hdr, short weed) { MESSAGE *msg = NULL; char file[_POSIX_PATH_MAX]; BODY *b; FILE *bfp; int rv = -1; STATE s; memset (&s, 0, sizeof (s)); if (!fp && (msg = mx_open_message (ctx, hdr->msgno)) == NULL) return (-1); if (!fp) fp = msg->fp; bfp = fp; /* parse the message header and MIME structure */ fseeko (fp, hdr->offset, 0); newhdr->offset = hdr->offset; newhdr->env = mutt_read_rfc822_header (fp, newhdr, 1, weed); newhdr->content->length = hdr->content->length; mutt_parse_part (fp, newhdr->content); mem_free (&newhdr->env->message_id); mem_free (&newhdr->env->mail_followup_to); /* really? */ /* decrypt pgp/mime encoded messages */ if ((WithCrypto & (APPLICATION_PGP | APPLICATION_SMIME) & hdr->security) && mutt_is_multipart_encrypted (newhdr->content)) { int ccap = WithCrypto & (APPLICATION_PGP | APPLICATION_SMIME) & hdr->security; newhdr->security |= ENCRYPT | ccap; if (!crypt_valid_passphrase (ccap)) goto err; mutt_message _("Decrypting message..."); if (((ccap & APPLICATION_PGP) && crypt_pgp_decrypt_mime (fp, &bfp, newhdr->content, &b) == -1) || ((ccap & APPLICATION_SMIME) && crypt_smime_decrypt_mime (fp, &bfp, newhdr->content, &b) == -1) || b == NULL) { err: mx_close_message (&msg); mutt_free_envelope (&newhdr->env); mutt_free_body (&newhdr->content); mutt_error _("Decryption failed."); return -1; } mutt_free_body (&newhdr->content); newhdr->content = b; mutt_clear_error (); } /* * remove a potential multipart/signed layer - useful when * resending messages */ if (WithCrypto && mutt_is_multipart_signed (newhdr->content)) { newhdr->security |= SIGN; if ((WithCrypto & APPLICATION_PGP) && ascii_strcasecmp (mutt_get_parameter ("protocol", newhdr->content->parameter), "application/pgp-signature") == 0) newhdr->security |= APPLICATION_PGP; else if ((WithCrypto & APPLICATION_SMIME)) newhdr->security |= APPLICATION_SMIME; /* destroy the signature */ mutt_free_body (&newhdr->content->parts->next); newhdr->content = mutt_remove_multipart (newhdr->content); } /* * We don't need no primary multipart. * Note: We _do_ preserve messages! * * XXX - we don't handle multipart/alternative in any * smart way when sending messages. However, one may * consider this a feature. * */ if (newhdr->content->type == TYPEMULTIPART) newhdr->content = mutt_remove_multipart (newhdr->content); s.fpin = bfp; /* create temporary files for all attachments */ for (b = newhdr->content; b; b = b->next) { /* what follows is roughly a receive-mode variant of * mutt_get_tmp_attachment () from muttlib.c */ file[0] = '\0'; if (b->filename) { strfcpy (file, b->filename, sizeof (file)); b->d_filename = str_dup (b->filename); } else { /* avoid Content-Disposition: header with temporary filename */ b->use_disp = 0; } /* set up state flags */ s.flags = 0; if (b->type == TYPETEXT) { if (!ascii_strcasecmp ("yes", mutt_get_parameter ("x-mutt-noconv", b->parameter))) b->noconv = 1; else { s.flags |= M_CHARCONV; b->noconv = 0; } mutt_delete_parameter ("x-mutt-noconv", &b->parameter); } mutt_adv_mktemp (NULL, file, sizeof (file)); if ((s.fpout = safe_fopen (file, "w")) == NULL) goto bail; if ((WithCrypto & APPLICATION_PGP) && (mutt_is_application_pgp (b) & (ENCRYPT | SIGN))) { mutt_body_handler (b, &s); newhdr->security |= mutt_is_application_pgp (newhdr->content); b->type = TYPETEXT; str_replace (&b->subtype, "plain"); mutt_delete_parameter ("x-action", &b->parameter); } else mutt_decode_attachment (b, &s); if (safe_fclose (&s.fpout) != 0) goto bail; str_replace (&b->filename, file); b->unlink = 1; mutt_stamp_attachment (b); mutt_free_body (&b->parts); if (b->hdr) b->hdr->content = NULL; /* avoid dangling pointer */ } /* Fix encryption flags. */ /* No inline if multipart. */ if (WithCrypto && (newhdr->security & INLINE) && newhdr->content->next) newhdr->security &= ~INLINE; /* Do we even support multiple mechanisms? */ newhdr->security &= WithCrypto | ~(APPLICATION_PGP | APPLICATION_SMIME); /* Theoretically, both could be set. Take the one the user wants to set by default. */ if ((newhdr->security & APPLICATION_PGP) && (newhdr->security & APPLICATION_SMIME)) { if (option (OPTSMIMEISDEFAULT)) newhdr->security &= ~APPLICATION_PGP; else newhdr->security &= ~APPLICATION_SMIME; } rv = 0; bail: /* that's it. */ if (bfp != fp) fclose (bfp); if (msg) mx_close_message (&msg); if (rv == -1) { mutt_free_envelope (&newhdr->env); mutt_free_body (&newhdr->content); } return rv; }
Message::Message(SQLite3DB::DB *db, const long dbmessageid, const long boardid):IDatabase(db),m_nntpmessageid(-1) { Option option(db); option.GetBool("UniqueBoardMessageIDs",m_uniqueboardmessageids); LoadDB(dbmessageid,boardid); }
/* Return the number of postponed messages. * if force is 0, use a cached value if it is costly to get a fresh * count (IMAP) - else check. */ int mutt_num_postponed (int force) { struct stat st; CONTEXT ctx; static time_t LastModify = 0; static char *OldPostponed = NULL; if (UpdateNumPostponed) { UpdateNumPostponed = 0; force = 1; } if (Postponed != OldPostponed) { OldPostponed = Postponed; LastModify = 0; force = 1; } if (!Postponed) return 0; #ifdef USE_IMAP /* LastModify is useless for IMAP */ if (imap_is_magic (Postponed, NULL) == M_IMAP) { if (force) { short newpc; newpc = imap_mailbox_check (Postponed, 0); if (newpc >= 0) { PostCount = newpc; debug_print (2, ("%d postponed IMAP messages found.\n", PostCount)); } else debug_print (2, ("using old IMAP postponed count.\n")); } return PostCount; } #endif if (stat (Postponed, &st) == -1) { PostCount = 0; LastModify = 0; return (0); } if (S_ISDIR (st.st_mode)) { /* if we have a maildir mailbox, we need to stat the "new" dir */ char buf[_POSIX_PATH_MAX]; snprintf (buf, sizeof (buf), "%s/new", Postponed); if (access (buf, F_OK) == 0 && stat (buf, &st) == -1) { PostCount = 0; LastModify = 0; return 0; } } if (LastModify < st.st_mtime) { #ifdef USE_NNTP int optnews = option (OPTNEWS); #endif LastModify = st.st_mtime; if (access (Postponed, R_OK | F_OK) != 0) return (PostCount = 0); #ifdef USE_NNTP if (optnews) unset_option (OPTNEWS); #endif if (mx_open_mailbox (Postponed, M_NOSORT | M_QUIET, &ctx) == NULL) PostCount = 0; else PostCount = ctx.msgcount; mx_fastclose_mailbox (&ctx); #ifdef USE_NNTP if (optnews) set_option (OPTNEWS); #endif } return (PostCount); }
/* this calculates whether a node is the root of a subtree that has visible * nodes, whether a node itself is visible, whether, if invisible, it has * depth anyway, and whether any of its later siblings are roots of visible * subtrees. while it's at it, it frees the old thread display, so we can * skip parts of the tree in mutt_draw_tree() if we've decided here that we * don't care about them any more. */ static void calculate_visibility (CONTEXT *ctx, int *max_depth) { THREAD *tmp, *tree = ctx->tree; int hide_top_missing = option (OPTHIDETOPMISSING) && !option (OPTHIDEMISSING); int hide_top_limited = option (OPTHIDETOPLIMITED) && !option (OPTHIDELIMITED); int depth = 0; /* we walk each level backwards to make it easier to compute next_subtree_visible */ while (tree->next) tree = tree->next; *max_depth = 0; FOREVER { if (depth > *max_depth) *max_depth = depth; tree->subtree_visible = 0; if (tree->message) { FREE (&tree->message->tree); if (VISIBLE (tree->message, ctx)) { tree->deep = 1; tree->visible = 1; tree->message->display_subject = need_display_subject (ctx, tree->message); for (tmp = tree; tmp; tmp = tmp->parent) { if (tmp->subtree_visible) { tmp->deep = 1; tmp->subtree_visible = 2; break; } else tmp->subtree_visible = 1; } } else { tree->visible = 0; tree->deep = !option (OPTHIDELIMITED); } } else { tree->visible = 0; tree->deep = !option (OPTHIDEMISSING); } tree->next_subtree_visible = tree->next && (tree->next->next_subtree_visible || tree->next->subtree_visible); if (tree->child) { depth++; tree = tree->child; while (tree->next) tree = tree->next; } else if (tree->prev) tree = tree->prev; else { while (tree && !tree->prev) { depth--; tree = tree->parent; } if (!tree) break; else tree = tree->prev; } } /* now fix up for the OPTHIDETOP* options if necessary */ if (hide_top_limited || hide_top_missing) { tree = ctx->tree; FOREVER { if (!tree->visible && tree->deep && tree->subtree_visible < 2 && ((tree->message && hide_top_limited) || (!tree->message && hide_top_missing))) tree->deep = 0; if (!tree->deep && tree->child && tree->subtree_visible) tree = tree->child; else if (tree->next) tree = tree->next; else { while (tree && !tree->next) tree = tree->parent; if (!tree) break; else tree = tree->next; } } }
PLAYER(AnimationManager &a, Level &lev,int x,int y):Entity(a,x,y) { option("Player",0,100,"stay"); STATE = stay; hit = 0; obj = lev.GetAllObjects(); }
int mutt_protect (HEADER *msg, char *keylist) { BODY *pbody = NULL, *tmp_pbody = NULL; BODY *tmp_smime_pbody = NULL; BODY *tmp_pgp_pbody = NULL; int flags = (WithCrypto & APPLICATION_PGP)? msg->security: 0; int i; if (!WithCrypto) return -1; if ((msg->security & SIGN) && !crypt_valid_passphrase (msg->security)) return (-1); if ((WithCrypto & APPLICATION_PGP) && ((msg->security & PGPINLINE) == PGPINLINE)) { /* they really want to send it inline... go for it */ if (!isendwin ()) mutt_endwin _("Invoking PGP..."); pbody = crypt_pgp_traditional_encryptsign (msg->content, flags, keylist); if (pbody) { msg->content = pbody; return 0; } /* otherwise inline won't work...ask for revert */ if ((i = query_quadoption (OPT_PGPMIMEAUTO, _("Message can't be sent inline. Revert to using PGP/MIME?"))) != M_YES) { mutt_error _("Mail not sent."); return -1; } /* go ahead with PGP/MIME */ } if (!isendwin ()) mutt_endwin (NULL); if ((WithCrypto & APPLICATION_SMIME)) tmp_smime_pbody = msg->content; if ((WithCrypto & APPLICATION_PGP)) tmp_pgp_pbody = msg->content; if (option (OPTCRYPTUSEPKA) && (msg->security & SIGN)) { /* Set sender (necessary for e.g. PKA). */ if ((WithCrypto & APPLICATION_SMIME) && (msg->security & APPLICATION_SMIME)) crypt_smime_set_sender (msg->env->from->mailbox); else if ((WithCrypto & APPLICATION_PGP) && (msg->security & APPLICATION_PGP)) crypt_pgp_set_sender (msg->env->from->mailbox); } if (msg->security & SIGN) { if ((WithCrypto & APPLICATION_SMIME) && (msg->security & APPLICATION_SMIME)) { if (!(tmp_pbody = crypt_smime_sign_message (msg->content))) return -1; pbody = tmp_smime_pbody = tmp_pbody; } if ((WithCrypto & APPLICATION_PGP) && (msg->security & APPLICATION_PGP) && (!(flags & ENCRYPT) || option (OPTPGPRETAINABLESIG))) { if (!(tmp_pbody = crypt_pgp_sign_message (msg->content))) return -1; flags &= ~SIGN; pbody = tmp_pgp_pbody = tmp_pbody; } if (WithCrypto && (msg->security & APPLICATION_SMIME) && (msg->security & APPLICATION_PGP)) { /* here comes the draft ;-) */ } } if (msg->security & ENCRYPT) { if ((WithCrypto & APPLICATION_SMIME) && (msg->security & APPLICATION_SMIME)) { if (!(tmp_pbody = crypt_smime_build_smime_entity (tmp_smime_pbody, keylist))) { /* signed ? free it! */ return (-1); } /* free tmp_body if messages was signed AND encrypted ... */ if (tmp_smime_pbody != msg->content && tmp_smime_pbody != tmp_pbody) { /* detatch and don't delete msg->content, which tmp_smime_pbody->parts after signing. */ tmp_smime_pbody->parts = tmp_smime_pbody->parts->next; msg->content->next = NULL; mutt_free_body (&tmp_smime_pbody); } pbody = tmp_pbody; } if ((WithCrypto & APPLICATION_PGP) && (msg->security & APPLICATION_PGP)) { if (!(pbody = crypt_pgp_encrypt_message (tmp_pgp_pbody, keylist, flags & SIGN))) { /* did we perform a retainable signature? */ if (flags != msg->security) { /* remove the outer multipart layer */ tmp_pgp_pbody = mutt_remove_multipart (tmp_pgp_pbody); /* get rid of the signature */ mutt_free_body (&tmp_pgp_pbody->next); } return (-1); } /* destroy temporary signature envelope when doing retainable * signatures. */ if (flags != msg->security) { tmp_pgp_pbody = mutt_remove_multipart (tmp_pgp_pbody); mutt_free_body (&tmp_pgp_pbody->next); } } } if(pbody) msg->content = pbody; return 0; }
void fPostStatus_db( const char* opt = "", const char* year = "17sim", const char* input = "fPostStatus.txt", int readdate = 0, int readtime = 0) { // storeTime is beginning time for validity range in case of WRITING DB TString option(opt), yr(year), storeTime; int date, time; // time for READING DB std::cout <<"year = " <<year <<std::endl; if (yr.Contains("17sim")) { storeTime = "2016-12-10 00:00:00"; date = 20161210; time = 0; } else if (yr.Contains("17ofl")) { storeTime = "2016-12-20 00:00:00"; date = 20161220; time = 0; } else { std::cout << "Please specify valid year tag\n"; exit; } if (readdate > 0) date = readdate; if (readtime > 0) time = readtime; std::cout << "Opt =" << opt << "\n"; std::cout << "write = " << option.Contains("writedb") << "\n"; std::cout << "storetime = " << storeTime << "\n"; std::cout << "date, time = " << date <<" "<< time << "\n"; gROOT->Macro("./loadlib.C"); //------------------------------------------- const Int_t MAX_DB_INDEX = 241; fpostStatus_st in[MAX_DB_INDEX]; FILE *FP = fopen(input, "r"); if (!FP) { printf("Could not open %s\n", input); exit; } printf("\nReading %s\n", input); char line[1000]; int n = 0; while (fgets(line, 1000, FP) != NULL) { sscanf(line,"%hu %hu", &in[n].slatid, &in[n].status); printf("slatId=%3d status=%1d\n", in[n].slatid, in[n].status); n++; } printf("Found %d entries\n", n); fclose(FP); printf("File Closed\n", n); //------------------------------------------- #if 1 if (option.Contains("writedb")) { gSystem->Setenv("DB_ACCESS_MODE", "write"); StDbManager* mgr = StDbManager::Instance(); StDbConfigNode* node = mgr->initConfig("Calibrations_fps"); StDbTable* dbtable = node->addDbTable("fpostStatus"); mgr->setStoreTime(storeTime.Data()); dbtable->SetTable((char*)&in, MAX_DB_INDEX); if (yr.Contains("sim")) dbtable->setFlavor("sim"); mgr->storeDbTable(dbtable); std::cout << "INFO: table saved to database" << std::endl; } //------------------------------------------- if (option.Contains("readdb")) { std::cout << "INFO: Reading database" << std::endl; gSystem->Unsetenv("DB_ACCESS_MODE"); //gSystem->Unsetenv("DB_SERVER_LOCAL_CONFIG"); St_db_Maker* dbMk = new St_db_Maker("db", "MySQL:StarDb", "$STAR/StarDb"); dbMk->SetDebug(); dbMk->SetDateTime(date, time); // event or run start time, set to your liking if (yr.Contains("ofl")) { dbMk->SetFlavor("ofl"); } else if (yr.Contains("sim")) { dbMk->SetFlavor("sim"); } dbMk->Init(); dbMk->Make(); TDataSet *DB = 0; DB = dbMk->GetDataBase("Calibrations/fps/fpostStatus"); if (!DB) std::cout << "ERROR: no table found in db, or malformed local db config" << std::endl; St_fpostStatus *dataset = 0; dataset = (St_fpostStatus*) DB->Find("fpostStatus"); if (!dataset) { std::cout << "ERROR: dataset does not contain requested table" << std::endl; return; } Int_t rows = dataset->GetNRows(); if (rows > 1) std::cout << "INFO: found INDEXED table with " << rows << " rows" << std::endl; TDatime val[2]; dbMk->GetValidity((TTable*)dataset, val); std::cout << "Dataset validity range: [ " << val[0].GetDate() << "." << val[0].GetTime() << " - " << val[1].GetDate() << "." << val[1].GetTime() << " ] " << std::endl; fpostStatus_st *table = (fpostStatus_st*)dataset->GetTable(); for (Int_t i = 0; i < rows; i++) { std::cout << Form("Row=%3d slatid=%3d status=%1d\n", i, table[i].slatid, table[i].status); } } #endif return; }//Main
static int interactive_check_cert (X509 *cert, int idx, int len) { static const char * const part[] = {"/CN=", "/Email=", "/O=", "/OU=", "/L=", "/ST=", "/C="}; char helpstr[LONG_STRING]; char buf[STRING]; char title[STRING]; MUTTMENU *menu = mutt_new_menu (-1); int done, row, i; FILE *fp; char *name = NULL, *c; dprint (2, (debugfile, "interactive_check_cert: %s\n", cert->name)); menu->max = 19; menu->dialog = (char **) safe_calloc (1, menu->max * sizeof (char *)); for (i = 0; i < menu->max; i++) menu->dialog[i] = (char *) safe_calloc (1, SHORT_STRING * sizeof (char)); row = 0; strfcpy (menu->dialog[row], _("This certificate belongs to:"), SHORT_STRING); row++; name = X509_NAME_oneline (X509_get_subject_name (cert), buf, sizeof (buf)); dprint (2, (debugfile, "oneline: %s\n", name)); for (i = 0; i < 5; i++) { c = x509_get_part (name, part[i]); snprintf (menu->dialog[row++], SHORT_STRING, " %s", c); } row++; strfcpy (menu->dialog[row], _("This certificate was issued by:"), SHORT_STRING); row++; name = X509_NAME_oneline (X509_get_issuer_name (cert), buf, sizeof (buf)); for (i = 0; i < 5; i++) { c = x509_get_part (name, part[i]); snprintf (menu->dialog[row++], SHORT_STRING, " %s", c); } row++; snprintf (menu->dialog[row++], SHORT_STRING, _("This certificate is valid")); snprintf (menu->dialog[row++], SHORT_STRING, _(" from %s"), asn1time_to_string (X509_get_notBefore (cert))); snprintf (menu->dialog[row++], SHORT_STRING, _(" to %s"), asn1time_to_string (X509_get_notAfter (cert))); row++; buf[0] = '\0'; x509_fingerprint (buf, sizeof (buf), cert); snprintf (menu->dialog[row++], SHORT_STRING, _("Fingerprint: %s"), buf); snprintf (title, sizeof (title), _("SSL Certificate check (certificate %d of %d in chain)"), len - idx, len); menu->title = title; if (SslCertFile && (option (OPTSSLVERIFYDATES) == M_NO || (X509_cmp_current_time (X509_get_notAfter (cert)) >= 0 && X509_cmp_current_time (X509_get_notBefore (cert)) < 0))) { menu->prompt = _("(r)eject, accept (o)nce, (a)ccept always"); menu->keys = _("roa"); } else { menu->prompt = _("(r)eject, accept (o)nce"); menu->keys = _("ro"); } helpstr[0] = '\0'; mutt_make_help (buf, sizeof (buf), _("Exit "), MENU_GENERIC, OP_EXIT); safe_strcat (helpstr, sizeof (helpstr), buf); mutt_make_help (buf, sizeof (buf), _("Help"), MENU_GENERIC, OP_HELP); safe_strcat (helpstr, sizeof (helpstr), buf); menu->help = helpstr; done = 0; set_option(OPTUNBUFFEREDINPUT); while (!done) { switch (mutt_menuLoop (menu)) { case -1: /* abort */ case OP_MAX + 1: /* reject */ case OP_EXIT: done = 1; break; case OP_MAX + 3: /* accept always */ done = 0; if ((fp = fopen (SslCertFile, "a"))) { if (PEM_write_X509 (fp, cert)) done = 1; safe_fclose (&fp); } if (!done) { mutt_error (_("Warning: Couldn't save certificate")); mutt_sleep (2); } else { mutt_message (_("Certificate saved")); mutt_sleep (0); } /* fall through */ case OP_MAX + 2: /* accept once */ done = 2; ssl_cache_trusted_cert (cert); break; } } unset_option(OPTUNBUFFEREDINPUT); mutt_menuDestroy (&menu); dprint (2, (debugfile, "ssl interactive_check_cert: done=%d\n", done)); return (done == 2); }
int main(int argc, char* argv[]) { int ch, n = 1, conn_timeout = 10, rw_timeout = 10, ttl = 10; acl::string addr("127.0.0.1:6379"), cmd; while ((ch = getopt(argc, argv, "hs:n:C:I:a:t:")) > 0) { switch (ch) { case 'h': usage(argv[0]); return 0; case 's': addr = optarg; break; case 'n': n = atoi(optarg); break; case 'C': conn_timeout = atoi(optarg); break; case 'I': rw_timeout = atoi(optarg); break; case 'a': cmd = optarg; break; case 't': ttl = atoi(optarg); break; default: break; } } acl::acl_cpp_init(); acl::log::stdout_open(true); acl::redis_client client(addr.c_str(), conn_timeout, rw_timeout); acl::redis_string option(&client); bool ret; if (cmd == "set") ret = test_set(option, n); else if (cmd == "setex") ret = test_setex(option, n, ttl); else if (cmd == "setnx") ret = test_setnx(option, n); else if (cmd == "append") ret = test_append(option, n); else if (cmd == "get") ret = test_get(option, n); else if (cmd == "getset") ret = test_getset(option, n); else if (cmd == "strlen") ret = test_strlen(option, n); else if (cmd == "mset") ret = test_mset(option, n); else if (cmd == "mget") ret = test_mget(option, n); else if (cmd == "msetnx") ret = test_msetnx(option, n); else if (cmd == "setrange") ret = test_setrange(option, n); else if (cmd == "getrange") ret = test_getrange(option, n); else if (cmd == "setbit") ret = test_setbit(option, n); else if (cmd == "getbit") ret = test_getbit(option, n); else if (cmd == "bitcount") ret = test_bitcount(option, n); else if (cmd == "bitop_and") ret = test_bitop_and(option, n); else if (cmd == "bitop_or") ret = test_bitop_or(option, n); else if (cmd == "bitop_xor") ret = test_bitop_xor(option, n); else if (cmd == "incr") ret = test_incr(option, n); else if (cmd == "incrby") ret = test_incrby(option, n); else if (cmd == "incrbyfloat") ret = test_incrbyfloat(option, n); else if (cmd == "decr") ret = test_decr(option, n); else if (cmd == "decrby") ret = test_decrby(option, n); else if (cmd == "all") { ret = test_set(option, n) && test_setex(option, n, ttl) && test_setnx(option, n) && test_append(option, n) && test_get(option, n) && test_getset(option, n) && test_strlen(option, n) && test_mset(option, n) && test_mget(option, n) && test_msetnx(option, n) && test_setrange(option, n) && test_getrange(option, n) && test_setbit(option, n) && test_getbit(option, n) && test_bitcount(option, n) && test_bitop_and(option, n) && test_bitop_or(option, n) && test_bitop_xor(option, n) && test_incr(option, n) && test_incrby(option, n) && test_incrbyfloat(option, n) && test_decr(option, n) && test_decrby(option, n); } else { ret = false; printf("unknown cmd: %s\r\n", cmd.c_str()); } if (ret == true) printf("test OK!\r\n"); else printf("test failed!\r\n"); #ifdef WIN32 printf("enter any key to exit\r\n"); getchar(); #endif return 0; }
/*! Returns the size of the operating system receive buffer. \sa setReceiveBufferSize() */ int Q3SocketDevice::receiveBufferSize() const { return option( ReceiveBuffer ); }
void DHCP::requested_ip(ipaddress_type addr) { uint32_t int_addr = addr; add_option(option(DHCP_REQUESTED_ADDRESS, sizeof(uint32_t), (uint8_t*)&int_addr)); }