/** * Set the protocol options. */ static int set_options(lua_State *L) { int i; const char *str; unsigned long flag = 0L; SSL_CTX *ctx = lsec_checkcontext(L, 1); int max = lua_gettop(L); /* any option? */ if (max > 1) { for (i = 2; i <= max; i++) { str = luaL_checkstring(L, i); #if !defined(SSL_OP_NO_COMPRESSION) && (OPENSSL_VERSION_NUMBER >= 0x0090800f) && (OPENSSL_VERSION_NUMBER < 0x1000000fL) /* Version 0.9.8 has a different way to disable compression */ if (!strcmp(str, "no_compression")) ctx->comp_methods = NULL; else #endif if (!set_option_flag(str, &flag)) { lua_pushboolean(L, 0); lua_pushfstring(L, "invalid option (%s)", str); return 2; } } SSL_CTX_set_options(ctx, flag); } lua_pushboolean(L, 1); return 1; }
/** * Set the protocol options. */ static int set_options(lua_State *L) { int i; unsigned long flag = 0L; SSL_CTX *ctx = ctx_getcontext(L, 1); int max = lua_gettop(L); /* any option? */ if (max > 1) { for (i = 2; i <= max; i++) { if (!set_option_flag(luaL_checkstring(L, i), &flag)) { lua_pushboolean(L, 0); lua_pushstring(L, "invalid option"); return 2; } } SSL_CTX_set_options(ctx, flag); } lua_pushboolean(L, 1); return 1; }
/** * @param argc * type *int * @param argv * type **char * @param pathsize * tpye *int : path size * @param pathList * type *char : read file name or path */ void control_argument(int *argc, char **argv, int *pathSize, char **pathList){ int i, j, strSize = 0; char *name; *pathSize = 0; for(i=1; i<*argc; i++){ if(*(*(argv+i)+0) == '\0') continue; strSize = strlen(*(argv+i)); if(*(*(argv+i)+0) == '-'){ for(j=1; j<strSize; j++){ set_option_flag(*(argv+i)+j); } }else{ *(pathList+*pathSize) = (char *) malloc(sizeof(char) * (strSize+1)); memcpy(*(pathList+((*pathSize)++)), *(argv+i), strSize+1); name = *(pathList+((*pathSize)-1)); // ~ newLine removal if(name[strlen(name)-1] == '\n'){ name[strlen(name)-1] = '\0'; } } } }
int cmd_set_window_option_exec(struct cmd *self, struct cmd_ctx *ctx) { struct cmd_option_data *data = self->data; struct winlink *wl; struct client *c; struct options *oo; const struct set_option_entry *entry; u_int i; if (data->flags & CMD_GFLAG) oo = &global_window_options; else { if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL) return (-1); oo = &wl->window->options; } if (*data->option == '\0') { ctx->error(ctx, "invalid option"); return (-1); } entry = NULL; for (i = 0; i < NSETWINDOWOPTION; i++) { if (strncmp(set_window_option_table[i].name, data->option, strlen(data->option)) != 0) continue; if (entry != NULL) { ctx->error(ctx, "ambiguous option: %s", data->option); return (-1); } entry = &set_window_option_table[i]; /* Bail now if an exact match. */ if (strcmp(entry->name, data->option) == 0) break; } if (entry == NULL) { ctx->error(ctx, "unknown option: %s", data->option); return (-1); } if (data->flags & CMD_UFLAG) { if (data->flags & CMD_GFLAG) { ctx->error(ctx, "can't unset global option: %s", entry->name); return (-1); } if (data->value != NULL) { ctx->error(ctx, "value passed to unset option: %s", entry->name); return (-1); } options_remove(oo, entry->name); ctx->info(ctx, "unset option: %s", entry->name); } else { switch (entry->type) { case SET_OPTION_STRING: set_option_string(ctx, oo, entry, data->value); break; case SET_OPTION_NUMBER: set_option_number(ctx, oo, entry, data->value); break; case SET_OPTION_KEY: set_option_key(ctx, oo, entry, data->value); break; case SET_OPTION_COLOUR: set_option_colour(ctx, oo, entry, data->value); break; case SET_OPTION_ATTRIBUTES: set_option_attributes(ctx, oo, entry, data->value); break; case SET_OPTION_FLAG: set_option_flag(ctx, oo, entry, data->value); break; case SET_OPTION_CHOICE: set_option_choice(ctx, oo, entry, data->value); break; } } recalculate_sizes(); for (i = 0; i < ARRAY_LENGTH(&clients); i++) { c = ARRAY_ITEM(&clients, i); if (c != NULL && c->session != NULL) server_redraw_client(c); } return (0); }
int cmd_list(int argc, const char **argv) { int i; bool raw_dump = false; bool long_desc_flag = false; struct option list_options[] = { OPT_BOOLEAN(0, "raw-dump", &raw_dump, "Dump raw events"), OPT_BOOLEAN('d', "desc", &desc_flag, "Print extra event descriptions. --no-desc to not print."), OPT_BOOLEAN('v', "long-desc", &long_desc_flag, "Print longer event descriptions."), OPT_BOOLEAN(0, "details", &details_flag, "Print information on the perf event names and expressions used internally by events."), OPT_INCR(0, "debug", &verbose, "Enable debugging output"), OPT_END() }; const char * const list_usage[] = { "perf list [<options>] [hw|sw|cache|tracepoint|pmu|sdt|event_glob]", NULL }; set_option_flag(list_options, 0, "raw-dump", PARSE_OPT_HIDDEN); argc = parse_options(argc, argv, list_options, list_usage, PARSE_OPT_STOP_AT_NON_OPTION); setup_pager(); if (!raw_dump && pager_in_use()) printf("\nList of pre-defined events (to be used in -e):\n\n"); if (argc == 0) { print_events(NULL, raw_dump, !desc_flag, long_desc_flag, details_flag); return 0; } for (i = 0; i < argc; ++i) { char *sep, *s; if (strcmp(argv[i], "tracepoint") == 0) print_tracepoint_events(NULL, NULL, raw_dump); else if (strcmp(argv[i], "hw") == 0 || strcmp(argv[i], "hardware") == 0) print_symbol_events(NULL, PERF_TYPE_HARDWARE, event_symbols_hw, PERF_COUNT_HW_MAX, raw_dump); else if (strcmp(argv[i], "sw") == 0 || strcmp(argv[i], "software") == 0) print_symbol_events(NULL, PERF_TYPE_SOFTWARE, event_symbols_sw, PERF_COUNT_SW_MAX, raw_dump); else if (strcmp(argv[i], "cache") == 0 || strcmp(argv[i], "hwcache") == 0) print_hwcache_events(NULL, raw_dump); else if (strcmp(argv[i], "pmu") == 0) print_pmu_events(NULL, raw_dump, !desc_flag, long_desc_flag, details_flag); else if (strcmp(argv[i], "sdt") == 0) print_sdt_events(NULL, NULL, raw_dump); else if (strcmp(argv[i], "metric") == 0) metricgroup__print(true, false, NULL, raw_dump, details_flag); else if (strcmp(argv[i], "metricgroup") == 0) metricgroup__print(false, true, NULL, raw_dump, details_flag); else if ((sep = strchr(argv[i], ':')) != NULL) { int sep_idx; if (sep == NULL) { print_events(argv[i], raw_dump, !desc_flag, long_desc_flag, details_flag); continue; } sep_idx = sep - argv[i]; s = strdup(argv[i]); if (s == NULL) return -1; s[sep_idx] = '\0'; print_tracepoint_events(s, s + sep_idx + 1, raw_dump); print_sdt_events(s, s + sep_idx + 1, raw_dump); metricgroup__print(true, true, s, raw_dump, details_flag); free(s); } else { if (asprintf(&s, "*%s*", argv[i]) < 0) { printf("Critical: Not enough memory! Trying to continue...\n"); continue; } print_symbol_events(s, PERF_TYPE_HARDWARE, event_symbols_hw, PERF_COUNT_HW_MAX, raw_dump); print_symbol_events(s, PERF_TYPE_SOFTWARE, event_symbols_sw, PERF_COUNT_SW_MAX, raw_dump); print_hwcache_events(s, raw_dump); print_pmu_events(s, raw_dump, !desc_flag, long_desc_flag, details_flag); print_tracepoint_events(NULL, s, raw_dump); print_sdt_events(NULL, s, raw_dump); metricgroup__print(true, true, s, raw_dump, details_flag); free(s); } } return 0; }
static ErlDrvSSizeT tls_drv_control(ErlDrvData handle, unsigned int command, char *buf, ErlDrvSizeT len, char **rbuf, ErlDrvSizeT rlen) { tls_data *d = (tls_data *)handle; int res; int size; ErlDrvBinary *b; X509 *cert; unsigned int flags = command; command &= 0xffff; ERR_clear_error(); switch (command) { case SET_CERTIFICATE_FILE_ACCEPT: case SET_CERTIFICATE_FILE_CONNECT: { time_t mtime = 0; char *protocol_options = (buf + strlen(buf) + 1) + strlen(buf + strlen(buf) + 1) + 1; long options = 0L; if (strlen(protocol_options) != 0) { char *po = strdup(protocol_options), delim[] = "|"; char *popts = po; char *strtok_buf; while ((po = strtok_r(po, delim, &strtok_buf)) != NULL) { set_option_flag(po, &options); po = NULL; } free(popts); } SSL_CTX *ssl_ctx = hash_table_lookup(buf, &mtime); if (is_key_file_modified(buf, &mtime) || ssl_ctx == NULL) { SSL_CTX *ctx; char *ciphers; hash_table_insert(buf, mtime, NULL); ctx = SSL_CTX_new(SSLv23_method()); die_unless(ctx, "SSL_CTX_new failed"); res = SSL_CTX_use_certificate_chain_file(ctx, buf); die_unless(res > 0, "SSL_CTX_use_certificate_file failed"); res = SSL_CTX_use_PrivateKey_file(ctx, buf, SSL_FILETYPE_PEM); die_unless(res > 0, "SSL_CTX_use_PrivateKey_file failed"); res = SSL_CTX_check_private_key(ctx); die_unless(res > 0, "SSL_CTX_check_private_key failed"); ciphers = buf + strlen(buf) + 1; if (strlen(ciphers) == 0) ciphers = CIPHERS; SSL_CTX_set_cipher_list(ctx, ciphers); #ifndef OPENSSL_NO_ECDH if (command == SET_CERTIFICATE_FILE_ACCEPT) { setup_ecdh(ctx); } #endif #ifndef OPENSSL_NO_DH if (command == SET_CERTIFICATE_FILE_ACCEPT) { setup_dh(ctx); } #endif SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF); SSL_CTX_set_default_verify_paths(ctx); #ifdef SSL_MODE_RELEASE_BUFFERS SSL_CTX_set_mode(ctx, SSL_MODE_RELEASE_BUFFERS); #endif /* SSL_CTX_load_verify_locations(ctx, "/etc/ejabberd/ca_certificates.pem", NULL); */ /* SSL_CTX_load_verify_locations(ctx, NULL, "/etc/ejabberd/ca_certs/"); */ /* This IF is commented to allow verification in all cases: */ /* if (command == SET_CERTIFICATE_FILE_ACCEPT) */ /* { */ SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER|SSL_VERIFY_CLIENT_ONCE, verify_callback); /* } */ SSL_CTX_set_info_callback(ctx, &ssl_info_callback); ssl_ctx = ctx; hash_table_insert(buf, mtime, ssl_ctx); } d->ssl = SSL_new(ssl_ctx); die_unless(d->ssl, "SSL_new failed"); if (flags & VERIFY_NONE) SSL_set_verify(d->ssl, SSL_VERIFY_NONE, verify_callback); #ifdef SSL_OP_NO_COMPRESSION if (flags & COMPRESSION_NONE) SSL_set_options(d->ssl, SSL_OP_NO_COMPRESSION); #endif SSL_set_ex_data(d->ssl, ssl_index, d); d->bio_read = BIO_new(BIO_s_mem()); d->bio_write = BIO_new(BIO_s_mem()); SSL_set_bio(d->ssl, d->bio_read, d->bio_write); if (command == SET_CERTIFICATE_FILE_ACCEPT) { options |= (SSL_OP_NO_TICKET|SSL_OP_ALL|SSL_OP_NO_SSLv2); SSL_set_options(d->ssl, options); SSL_set_accept_state(d->ssl); } else { options |= (SSL_OP_NO_TICKET|SSL_OP_NO_SSLv2); SSL_set_options(d->ssl, options); SSL_set_connect_state(d->ssl); } break; } case SET_ENCRYPTED_INPUT: die_unless(d->ssl, "SSL not initialized"); BIO_write(d->bio_read, buf, len); break; case SET_DECRYPTED_OUTPUT: die_unless(d->ssl, "SSL not initialized"); res = SSL_write(d->ssl, buf, len); if (res <= 0) { res = SSL_get_error(d->ssl, res); if (res == SSL_ERROR_WANT_READ || res == SSL_ERROR_WANT_WRITE) { b = driver_alloc_binary(1); b->orig_bytes[0] = 2; *rbuf = (char *)b; return 1; } else { die_unless(0, "SSL_write failed"); } } break; case GET_ENCRYPTED_OUTPUT: die_unless(d->ssl, "SSL not initialized"); size = BIO_ctrl_pending(d->bio_write) + 1; b = driver_alloc_binary(size); b->orig_bytes[0] = 0; BIO_read(d->bio_write, b->orig_bytes + 1, size - 1); *rbuf = (char *)b; return size; case GET_DECRYPTED_INPUT: if (!SSL_is_init_finished(d->ssl)) { res = SSL_do_handshake(d->ssl); if (res <= 0) die_unless(SSL_get_error(d->ssl, res) == SSL_ERROR_WANT_READ, "SSL_do_handshake failed"); } if (SSL_is_init_finished(d->ssl)) { size_t req_size = 0; if (len == 4) { unsigned char *b = (unsigned char *)buf; req_size = (b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3]; } size = BUF_SIZE + 1; rlen = 1; b = driver_alloc_binary(size); b->orig_bytes[0] = 0; res = 0; while ((req_size == 0 || rlen < req_size + 1) && (res = SSL_read(d->ssl, b->orig_bytes + rlen, (req_size == 0 || req_size + 1 >= size) ? size - rlen : req_size + 1 - rlen)) > 0) { //printf("%d bytes of decrypted data read from state machine\r\n",res); rlen += res; if (size - rlen < BUF_SIZE) { size *= 2; b = driver_realloc_binary(b, size); } } if (d->handshakes > 1) { char *error = "client renegotiations forbidden"; int error_len = strlen(error); rlen = error_len + 1; b = driver_alloc_binary(rlen); b->orig_bytes[0] = 1; strncpy(b->orig_bytes + 1, error, error_len); *rbuf = (char *)b; return rlen; } if (res < 0) { int err = SSL_get_error(d->ssl, res); if (err == SSL_ERROR_WANT_READ) { //printf("SSL_read wants more data\r\n"); //return 0; } // TODO } b = driver_realloc_binary(b, rlen); *rbuf = (char *)b; return rlen; } break; case GET_PEER_CERTIFICATE: cert = SSL_get_peer_certificate(d->ssl); if (cert == NULL) { b = driver_alloc_binary(1); b->orig_bytes[0] = 1; *rbuf = (char *)b; return 1; } else { unsigned char *tmp_buf; rlen = i2d_X509(cert, NULL); if (rlen >= 0) { rlen++; b = driver_alloc_binary(rlen); b->orig_bytes[0] = 0; tmp_buf = (unsigned char *)&b->orig_bytes[1]; i2d_X509(cert, &tmp_buf); X509_free(cert); *rbuf = (char *)b; return rlen; } else X509_free(cert); } break; case GET_VERIFY_RESULT: b = driver_alloc_binary(1); b->orig_bytes[0] = SSL_get_verify_result(d->ssl); *rbuf = (char *)b; return 1; break; } b = driver_alloc_binary(1); b->orig_bytes[0] = 0; *rbuf = (char *)b; return 1; }