static void regress_sockaddr_port_format(void *ptr) { struct sockaddr_storage ss; int len; const char *cp; char cbuf[128]; int r; len = sizeof(ss); r = evutil_parse_sockaddr_port("192.168.1.1:80", (struct sockaddr*)&ss, &len); tt_int_op(r,==,0); cp = evutil_format_sockaddr_port_( (struct sockaddr*)&ss, cbuf, sizeof(cbuf)); tt_ptr_op(cp,==,cbuf); tt_str_op(cp,==,"192.168.1.1:80"); len = sizeof(ss); r = evutil_parse_sockaddr_port("[ff00::8010]:999", (struct sockaddr*)&ss, &len); tt_int_op(r,==,0); cp = evutil_format_sockaddr_port_( (struct sockaddr*)&ss, cbuf, sizeof(cbuf)); tt_ptr_op(cp,==,cbuf); tt_str_op(cp,==,"[ff00::8010]:999"); ss.ss_family=99; cp = evutil_format_sockaddr_port_( (struct sockaddr*)&ss, cbuf, sizeof(cbuf)); tt_ptr_op(cp,==,cbuf); tt_str_op(cp,==,"<addr with socktype 99>"); end: ; }
void main(int argc, char **argv) { int server_addrlen; struct evconnlistener *listener; base = event_base_new(); if (!base) { perror("event_base_new()"); exit(1); } memset(&client_addr, 0, sizeof(client_addr)); memset(&server_addr, 0, sizeof(server_addr)); client_addrlen = sizeof(client_addr); server_addrlen = sizeof(server_addr); evutil_parse_sockaddr_port(argv[1], (struct sockaddr*)&server_addr, &server_addrlen); evutil_parse_sockaddr_port(argv[2], (struct sockaddr*)&client_addr, &client_addrlen); listener = evconnlistener_new_bind(base, accept_cb, NULL, LEV_OPT_CLOSE_ON_FREE|LEV_OPT_CLOSE_ON_EXEC|LEV_OPT_REUSEABLE, -1, (struct sockaddr*)&server_addr, server_addrlen); event_base_dispatch(base); evconnlistener_free(listener); event_base_free(base); }
int main(int argc, char **argv) { int socklen; struct evconnlistener *listener; if (argc < 3) syntax(); memset(&listen_on_addr, 0, sizeof(listen_on_addr)); socklen = sizeof(listen_on_addr); if (evutil_parse_sockaddr_port(argv[1], (struct sockaddr*)&listen_on_addr, &socklen) < 0) { int p = atoi(argv[1]); struct sockaddr_in *sin = (struct sockaddr_in*)&listen_on_addr; if (p < 1 || p > 65535) syntax(); sin->sin_port = htons(p); sin->sin_addr.s_addr = htonl(0x7f000001); sin->sin_family = AF_INET; socklen = sizeof(struct sockaddr_in); } memset(&connect_to_addr, 0, sizeof(connect_to_addr)); connect_to_addrlen = sizeof(connect_to_addr); if (evutil_parse_sockaddr_port(argv[2], (struct sockaddr*)&connect_to_addr, &connect_to_addrlen) < 0) syntax(); base = event_base_new(); if (!base) { perror("event_base_new()"); return 1; } listener = evconnlistener_new_bind(base, accept_cb, NULL, LEV_OPT_CLOSE_ON_FREE|LEV_OPT_CLOSE_ON_EXEC|LEV_OPT_REUSEABLE, -1, (struct sockaddr*)&listen_on_addr, socklen); if (! listener) { fprintf(stderr, "Couldn't open listener.\n"); event_base_free(base); return 1; } event_base_dispatch(base); evconnlistener_free(listener); event_base_free(base); return 0; }
// only in child void child(Dict* config, struct ChildContext* context) { context->dataFromParent = event_new(context->eventBase, context->inFd, EV_READ | EV_PERSIST, incomingFromParent, context); event_add(context->dataFromParent, NULL); struct sockaddr_storage addr; int addrLen = sizeof(struct sockaddr_storage); char* bindTo = "127.0.0.1:9999"; String* bindStr = Dict_getString(config, BSTR("bind")); if (bindStr) { fprintf(stderr, "Admin: Binding to %s\n", bindStr->bytes); if (evutil_parse_sockaddr_port(bindStr->bytes, (struct sockaddr*) &addr, &addrLen)) { fprintf(stderr, "Admin: admin.bind parse failed, calling back on %s\n", bindTo); bindStr = NULL; } } if (!bindStr) { fprintf(stderr, "Admin: Binding to %s\n", bindTo); evutil_parse_sockaddr_port(bindTo, (struct sockaddr*) &addr, &addrLen); } evutil_socket_t listener = socket(addr.ss_family, SOCK_STREAM, 0); evutil_make_socket_nonblocking(listener); evutil_make_listen_socket_reuseable(listener); if (bind(listener, (struct sockaddr*)&addr, sizeof(addr)) < 0) { perror("bind"); return; } if (listen(listener, 16)<0) { perror("listen"); return; } context->socketEvent = event_new(context->eventBase, listener, EV_READ | EV_PERSIST, acceptConn, context); event_add(context->socketEvent, NULL); if (!context->eventBase) { exit(-1); } event_base_dispatch(context->eventBase); }
int main (int argc, char const *argv[]) { int rate; struct event_base* base; struct bufferevent* bev; struct sockaddr address; int address_len = sizeof(struct sockaddr); if (argc != 3) usage(argv[0]); if (evutil_parse_sockaddr_port(argv[1], &address, &address_len) == -1) usage(argv[0]); rate = atoi(argv[2]); base = event_base_new(); bev = connect_to_proposer(base, &address); char value[] = "hello!"; int len = strlen(value) + 1; while(1) { int i; for (i = 0; i < rate; ++i) { paxos_submit(bev, value, len); event_base_dispatch(base); //分发事件 } sleep(10); } return 0; }
static void reconf(struct event_base* eventbase, Dict* mainConf, struct Log* logger, struct Allocator* alloc) { Dict* adminConf = Dict_getDict(mainConf, String_CONST("admin")); String* address = Dict_getString(adminConf, String_CONST("bind")); String* password = Dict_getString(adminConf, String_CONST("password")); if (!(address && password)) { Log_critical(logger, "Can't get the admin address and password from conf file."); exit(-1); } struct sockaddr_storage addr; memset(&addr, 0, sizeof(struct sockaddr_storage)); int addrLen = sizeof(struct sockaddr_storage); if (evutil_parse_sockaddr_port(address->bytes, (struct sockaddr*) &addr, &addrLen)) { Log_critical(logger, "Unable to parse [%s] as an ip address port, " "eg: 127.0.0.1:11234", address->bytes); exit(-1); } Configurator_config(mainConf, &addr, addrLen, password, eventbase, logger, alloc); }
bool TorControlConnection::Connect(const std::string &target, const ConnectionCB& _connected, const ConnectionCB& _disconnected) { if (b_conn) Disconnect(); // Parse target address:port struct sockaddr_storage connect_to_addr; int connect_to_addrlen = sizeof(connect_to_addr); if (evutil_parse_sockaddr_port(target.c_str(), (struct sockaddr*)&connect_to_addr, &connect_to_addrlen)<0) { LogPrintf("tor: Error parsing socket address %s\n", target); return false; } // Create a new socket, set up callbacks and enable notification bits b_conn = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE); if (!b_conn) return false; bufferevent_setcb(b_conn, TorControlConnection::readcb, NULL, TorControlConnection::eventcb, this); bufferevent_enable(b_conn, EV_READ|EV_WRITE); this->connected = _connected; this->disconnected = _disconnected; // Finally, connect to target if (bufferevent_socket_connect(b_conn, (struct sockaddr*)&connect_to_addr, connect_to_addrlen) < 0) { LogPrintf("tor: Error connecting to address %s\n", target); return false; } return true; }
btc_bool btc_node_set_ipport(btc_node *node, const char *ipport) { int outlen = (int)sizeof(node->addr); //return true in case of success (0 == no error) return (evutil_parse_sockaddr_port(ipport, &node->addr, &outlen) == 0); }
int main(int argc, char **argv) { struct sockaddr_in serv_addr; struct event_base *base; struct bufferevent *bev, *bev_stdout; int i, addr_len = sizeof serv_addr; struct timeval timeout = {1, 0}; base = event_base_new(); if (evutil_parse_sockaddr_port("127.0.0.1:8200", (struct sockaddr *)&serv_addr, &addr_len)) { printf("evutil_parse_sockaddr_port"); exit(1); } for (i = 0; i < 10; i++) { bev = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE); bufferevent_setcb(bev, readcb, writecb, eventcb, NULL); bufferevent_enable(bev, EV_READ | EV_WRITE); bufferevent_set_timeouts(bev, &timeout, &timeout); evbuffer_add_printf(bufferevent_get_output(bev), websocket_request); if (bufferevent_socket_connect(bev, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) { bufferevent_free(bev); printf("bufferevent_socket_connect"); exit(1); } } event_base_dispatch(base); }
bufferevent * connect_by_ipport(const char * ip_port) { bufferevent * bev =NULL; do { struct sockaddr saddr; int saddr_len =sizeof(saddr); if(0!=evutil_parse_sockaddr_port(ip_port, &saddr, &saddr_len)) { printf("evutil_parse_sockaddr_port failed! \n"); break; } bev = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE); int rt =bufferevent_socket_connect(bev,(struct sockaddr *)&saddr, sizeof(saddr)); if ( rt!= 0) { bufferevent_free(bev); break; } bufferevent_setcb(bev, readcb, writecb, eventcb, NULL); bufferevent_enable(bev, EV_READ|EV_WRITE); } while (0); return bev; }
int endpoint_set_ipport(struct endpoint *e, char const *ip) { return evutil_parse_sockaddr_port(ip, (struct sockaddr *)&e->addr, (int *)&e->addrlen); }
struct UDPInterface* UDPInterface_new(struct event_base* base, const char* bindAddr, struct Allocator* allocator, struct ExceptionHandler* exHandler, struct Log* logger) { struct UDPInterface* context = allocator->calloc(sizeof(struct UDPInterface), 1, allocator); context->messageBuff = allocator->calloc(MAX_PACKET_SIZE + PADDING, 1, allocator); context->logger = logger; context->allocator = allocator; sa_family_t addrFam; struct sockaddr_storage addr; if (bindAddr != NULL) { context->addrLen = sizeof(struct sockaddr_storage); if (0 != evutil_parse_sockaddr_port(bindAddr, (struct sockaddr*) &addr, &context->addrLen)) { exHandler->exception(__FILE__ " UDPInterface_new() Failed to parse address.", -1, exHandler); return NULL; } addrFam = addr.ss_family; } else { addrFam = AF_INET; context->addrLen = sizeof(struct sockaddr); } context->socket = socket(addrFam, SOCK_DGRAM, 0); if (context->socket == -1) { exHandler->exception(__FILE__ " UDPInterface_new() call to socket() failed.", -3, exHandler); return NULL; } if (bindAddr != NULL) { if(bind(context->socket, (struct sockaddr*) &addr, context->addrLen)) { exHandler->exception(__FILE__ " UDPInterface_new() Failed to bind socket.", errno, exHandler); return NULL; } } evutil_make_socket_nonblocking(context->socket); context->incomingMessageEvent = event_new(base, context->socket, EV_READ | EV_PERSIST, handleEvent, context); if (context->incomingMessageEvent == NULL) { exHandler->exception(__FILE__ " UDPInterface_new() failed to create UDPInterface event.", -4, exHandler); return NULL; } event_add(context->incomingMessageEvent, NULL); allocator->onFree(freeEvent, context->incomingMessageEvent, allocator); return context; }
static int sockaddr_from_ip_and_port(struct sockaddr_storage * const sockaddr, ev_socklen_t * const sockaddr_len_p, const char * const ip, const char * const port, const char * const error_msg) { char sockaddr_port[INET6_ADDRSTRLEN + sizeof "[]:65535"]; int sockaddr_len_int; char *pnt; _Bool has_column = 0; _Bool has_columns = 0; _Bool has_brackets = *ip == '['; if ((pnt = strchr(ip, ':')) != NULL) { has_column = 1; if (strchr(pnt + 1, ':') != NULL) { has_columns = 1; } } sockaddr_len_int = (int) sizeof *sockaddr; if ((has_brackets != 0 || has_column != has_columns) && evutil_parse_sockaddr_port(ip, (struct sockaddr *) sockaddr, &sockaddr_len_int) == 0) { *sockaddr_len_p = (ev_socklen_t) sockaddr_len_int; return 0; } if (has_columns != 0 && has_brackets == 0) { evutil_snprintf(sockaddr_port, sizeof sockaddr_port, "[%s]:%s", ip, port); } else { evutil_snprintf(sockaddr_port, sizeof sockaddr_port, "%s:%s", ip, port); } sockaddr_len_int = (int) sizeof *sockaddr; if (evutil_parse_sockaddr_port(sockaddr_port, (struct sockaddr *) sockaddr, &sockaddr_len_int) != 0) { logger(NULL, LOG_ERR, "%s: %s", error_msg, sockaddr_port); *sockaddr_len_p = (ev_socklen_t) 0U; return -1; } *sockaddr_len_p = (ev_socklen_t) sockaddr_len_int; return 0; }
static void regress_sockaddr_port_parse(void *ptr) { struct sockaddr_storage ss; int i, r; for (i = 0; sa_port_ents[i].parse; ++i) { struct sa_port_ent *ent = &sa_port_ents[i]; int len = sizeof(ss); memset(&ss, 0, sizeof(ss)); r = evutil_parse_sockaddr_port(ent->parse, (struct sockaddr*)&ss, &len); if (r < 0) { if (ent->safamily) TT_FAIL(("Couldn't parse %s!", ent->parse)); continue; } else if (! ent->safamily) { TT_FAIL(("Shouldn't have been able to parse %s!", ent->parse)); continue; } if (ent->safamily == AF_INET) { struct sockaddr_in sin; memset(&sin, 0, sizeof(sin)); #ifdef EVENT__HAVE_STRUCT_SOCKADDR_IN_SIN_LEN sin.sin_len = sizeof(sin); #endif sin.sin_family = AF_INET; sin.sin_port = htons(ent->port); r = evutil_inet_pton(AF_INET, ent->addr, &sin.sin_addr); if (1 != r) { TT_FAIL(("Couldn't parse ipv4 target %s.", ent->addr)); } else if (memcmp(&sin, &ss, sizeof(sin))) { TT_FAIL(("Parse for %s was not as expected.", ent->parse)); } else if (len != sizeof(sin)) { TT_FAIL(("Length for %s not as expected.",ent->parse)); } } else { struct sockaddr_in6 sin6; memset(&sin6, 0, sizeof(sin6)); #ifdef EVENT__HAVE_STRUCT_SOCKADDR_IN6_SIN6_LEN sin6.sin6_len = sizeof(sin6); #endif sin6.sin6_family = AF_INET6; sin6.sin6_port = htons(ent->port); r = evutil_inet_pton(AF_INET6, ent->addr, &sin6.sin6_addr); if (1 != r) { TT_FAIL(("Couldn't parse ipv6 target %s.", ent->addr)); } else if (memcmp(&sin6, &ss, sizeof(sin6))) { TT_FAIL(("Parse for %s was not as expected.", ent->parse)); } else if (len != sizeof(sin6)) { TT_FAIL(("Length for %s not as expected.",ent->parse)); } } } }
cTCPLinkImplPtr cTCPLinkImpl::Connect(const AString & a_Host, UInt16 a_Port, cTCPLink::cCallbacksPtr a_LinkCallbacks, cNetwork::cConnectCallbacksPtr a_ConnectCallbacks) { ASSERT(a_LinkCallbacks != nullptr); ASSERT(a_ConnectCallbacks != nullptr); // Create a new link: cTCPLinkImplPtr res{new cTCPLinkImpl(a_LinkCallbacks)}; // Cannot use std::make_shared here, constructor is not accessible res->m_ConnectCallbacks = a_ConnectCallbacks; cNetworkSingleton::Get().AddLink(res); res->m_Callbacks->OnLinkCreated(res); res->Enable(res); // If a_Host is an IP address, schedule a connection immediately: sockaddr_storage sa; int salen = static_cast<int>(sizeof(sa)); if (evutil_parse_sockaddr_port(a_Host.c_str(), reinterpret_cast<sockaddr *>(&sa), &salen) == 0) { // Insert the correct port: if (sa.ss_family == AF_INET6) { reinterpret_cast<sockaddr_in6 *>(&sa)->sin6_port = htons(a_Port); } else { reinterpret_cast<sockaddr_in *>(&sa)->sin_port = htons(a_Port); } // Queue the connect request: if (bufferevent_socket_connect(res->m_BufferEvent, reinterpret_cast<sockaddr *>(&sa), salen) == 0) { // Success return res; } // Failure cNetworkSingleton::Get().RemoveLink(res.get()); return nullptr; } // a_Host is a hostname, connect after a lookup: if (bufferevent_socket_connect_hostname(res->m_BufferEvent, cNetworkSingleton::Get().GetDNSBase(), AF_UNSPEC, a_Host.c_str(), a_Port) == 0) { // Success return res; } // Failure cNetworkSingleton::Get().RemoveLink(res.get()); return nullptr; }
// Listen for socket connections on a particular interface. void server_listen(struct event_base *evbase, conninfo_t *conninfo) { struct sockaddr_in sin; int len; assert(evbase); assert(_evbase == NULL); _evbase = evbase; assert(_maxconns > 0); assert(_conncount == 0); assert(_listener == NULL); memset(&sin, 0, sizeof(sin)); // sin.sin_family = AF_INET; len = sizeof(sin); assert(_conninfo == NULL); _conninfo = conninfo; const char *remote_addr = conninfo_remoteaddr(_conninfo); assert(remote_addr); assert(sizeof(struct sockaddr_in) == sizeof(struct sockaddr)); if (evutil_parse_sockaddr_port(remote_addr, (struct sockaddr *)&sin, &len) != 0) { assert(0); } else { assert(_listener == NULL); assert(_evbase); logger(LOG_INFO, "listen: %s", remote_addr); _listener = evconnlistener_new_bind( _evbase, accept_conn_cb, NULL, LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE, -1, (struct sockaddr*)&sin, sizeof(sin) ); assert(_listener); } }
int main(int argc, char* argv[]) { daemon(1, 1); glog_init(argv[0]); sockaddr addr; int len = sizeof(sockaddr); evutil_parse_sockaddr_port("127.0.0.1:5000", &addr, &len); event_base* pbase = event_base_new(); char test[32] = "test data"; evconnlistener* plistener = evconnlistener_new_bind(pbase, listener_cb, reinterpret_cast<void*>(test), LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, 10, &addr, len); LOG(INFO) << evconnlistener_get_fd(plistener); event_base_dispatch(pbase); evconnlistener_free(plistener); event_base_free(pbase); return 0; }
static struct Admin* newAdmin(Dict* mainConf, char* user, struct Log* logger, struct event_base* eventBase, struct Allocator* alloc) { Dict* adminConf = Dict_getDict(mainConf, String_CONST("admin")); String* address = Dict_getString(adminConf, String_CONST("bind")); String* password = Dict_getString(adminConf, String_CONST("password")); struct sockaddr_storage addr; int addrLen = sizeof(struct sockaddr_storage); memset(&addr, 0, sizeof(struct sockaddr_storage)); if (address) { if (evutil_parse_sockaddr_port(address->bytes, (struct sockaddr*) &addr, &addrLen)) { Log_critical(logger, "Unable to parse [%s] as an ip address port, " "eg: 127.0.0.1:11234", address->bytes); exit(-1); } } if (!password) { uint8_t buff[32]; randomBase32(buff); password = String_new((char*)buff, alloc); } struct Admin* admin = Admin_new(&addr, addrLen, password, user, eventBase, AbortHandler_INSTANCE, logger, alloc); return admin; }
static void test_evutil_sockaddr_predicates(void *ptr) { struct sockaddr_storage ss; int r, i; for (i=0; sa_pred_entries[i].parse; ++i) { struct sa_pred_ent *ent = &sa_pred_entries[i]; int len = sizeof(ss); r = evutil_parse_sockaddr_port(ent->parse, (struct sockaddr*)&ss, &len); if (r<0) { TT_FAIL(("Couldn't parse %s!", ent->parse)); continue; } /* sockaddr_is_loopback */ if (ent->is_loopback != evutil_sockaddr_is_loopback_((struct sockaddr*)&ss)) { TT_FAIL(("evutil_sockaddr_loopback(%s) not as expected", ent->parse)); } } }
int main(int argc, char** argv) { /* Set the CWD */ char *home = getenv("HOME"); if (!home) { printf("Failed to load data directory\n"); return EXIT_FAILURE; } char *datadir = malloc(strlen(home) + 10); snprintf(datadir, strlen(home) + 10, "%s/.bitpeer", home); if (chdir(datadir) < 0) { if (mkdir(datadir, 0777) < 0) { printf("Failed to create data directory.\n"); return EXIT_FAILURE; } if (chdir(datadir) < 0) { printf("Failed to chdir\n"); return EXIT_FAILURE; } } free(datadir); /* For safety we do these protocol struct assertions */ assert(sizeof(bp_proto_message_s) == 24); assert(sizeof(bp_proto_net_addr_s) == 26); assert(sizeof(bp_proto_net_addr_full_s) == 30); assert(sizeof(bp_proto_version_s) == 80); assert(sizeof(bp_proto_inv_s) == 36); assert(sizeof(bp_btcblock_header_s) == 80); /* Set the settings */ bp_program_s program; memset(&program, 0, sizeof(program)); program.addrpool_size = 20480; program.min_connections = 8; program.max_connections = 4096; program.reindex_blocks = 0; program.relay_transactions = 1; program.relay_blocks = 1; program.txpool_size = 1024; program.blocks_per_getblocks = 500; /* Interpret the command line */ if (argc < 2) { printf("Invalid command line arguments.\n"); printf("Usage: bitpeer [listen_port] [public_ip] -n [seed_node]\n"); printf("public_ip and seed_node may optionally contain a port number.\n"); return EXIT_FAILURE; } unsigned short listen_port = atoi(argv[1]); if (listen_port == 0) { printf("Invalid port number specified. Valid ports go from 1 to 65535.\n"); return EXIT_FAILURE; } struct sockaddr_in6 sockaddr; int sockaddr_len = sizeof(struct sockaddr_in6); if (evutil_parse_sockaddr_port(argv[2], (struct sockaddr*)&sockaddr, &sockaddr_len) < 0) { printf("Invalid public_ip specified\n"); return EXIT_FAILURE; } if (sockaddr.sin6_family == AF_INET) { sockaddr = bp_in4to6((struct sockaddr_in*)&sockaddr); sockaddr_len = sizeof(struct sockaddr_in6); } if (sockaddr.sin6_port == 0) { sockaddr.sin6_port = ntohs(listen_port); } int nodecount = 0; struct sockaddr_in6 *nodeaddrs = NULL; int *nodelens = NULL; int *nodeperm = NULL; /* Now interpret the optional arguments */ // Quick preprocessor macro to go to the next argv #define NEXT_I() {i++; if (i >= argc) { printf("Argument for %s missing\n", argv[i-1]); return EXIT_FAILURE; }} for (int i = 3; i < argc; i++) { if (strcmp(argv[i], "--reindex") == 0) { program.reindex_blocks = 1; } else if (strcmp(argv[i], "--addnode") == 0 || strcmp(argv[i], "-n") == 0 || strcmp(argv[i], "--addpnode") == 0 || strcmp(argv[i], "-p") == 0) { NEXT_I(); nodeaddrs = realloc(nodeaddrs, (nodecount+1) * sizeof(struct sockaddr_in6)); nodelens = realloc(nodelens, (nodecount+1) * sizeof(int)); nodeperm = realloc(nodeperm, (nodecount+1) * sizeof(int)); nodelens[nodecount] = sizeof(struct sockaddr_in6); nodeperm[nodecount] = 0; if (strcmp(argv[i-1], "--addpnode") == 0 || strcmp(argv[i-1], "-p") == 0) { printf("Adding a permanent node\n"); nodeperm[nodecount] = 1; } struct sockaddr_in6 *addr = &nodeaddrs[nodecount]; memset(addr, 0, sizeof(struct sockaddr_in6)); if (evutil_parse_sockaddr_port(argv[i], (struct sockaddr*)addr, nodelens+nodecount) < 0) { printf("Invalid node address specified: %s %d\n", argv[i], nodelens[nodecount]); return EXIT_FAILURE; } if (addr->sin6_family == AF_INET) { *addr = bp_in4to6((struct sockaddr_in*)addr); nodelens[nodecount] = sizeof(struct sockaddr_in6); } assert(addr->sin6_family == AF_INET6); if (addr->sin6_port == 0) addr->sin6_port = ntohs(8333); nodecount += 1; } else if (strcmp(argv[i], "--txpool") == 0) { NEXT_I(); program.txpool_size = atoi(argv[i]); if (program.txpool_size <= 0) { printf("Invalid argument for %s\n", argv[i-1]); return EXIT_FAILURE; } } else if (strcmp(argv[i], "--addrpool") == 0) { NEXT_I(); program.addrpool_size = atoi(argv[i]); if (program.addrpool_size <= 0) { printf("Invalid argument for %s\n", argv[i-1]); return EXIT_FAILURE; } } else if (strcmp(argv[i], "--getblocks-limit") == 0) { NEXT_I(); program.blocks_per_getblocks = atoi(argv[i]); if (program.blocks_per_getblocks == 0) { printf("Invalid argument for %s\n", argv[i-1]); return EXIT_FAILURE; } } else if (strcmp(argv[i], "--no-tx") == 0) { program.relay_transactions = 0; } else if (strcmp(argv[i], "--no-blocks") == 0) { program.relay_blocks = 0; } else if (strcmp(argv[i], "--minconn") == 0) { NEXT_I(); program.min_connections = atoi(argv[i]); } else if (strcmp(argv[i], "--maxconn") == 0) { NEXT_I(); program.max_connections = atoi(argv[i]); if (program.max_connections <= 0) { printf("Invalid argument for %s\n", argv[i-1]); return EXIT_FAILURE; } } else if (strcmp(argv[i], "--evdebug") == 0) { #ifdef EVENT_DBG_ALL event_enable_debug_logging(EVENT_DBG_ALL); #endif event_set_log_callback(log_cb); event_enable_debug_mode(); } else { printf("Unknown argument '%s'\n", argv[i]); return EXIT_FAILURE; } } /* Ignore SIGPIPE */ struct sigaction act; act.sa_handler = SIG_IGN; sigemptyset(&act.sa_mask); act.sa_flags = 0; sigaction(SIGPIPE, &act, NULL); /* Create the main loop */ bp_program_init(&program); program.eventbase = event_base_new(); /* Set up the signal handler */ struct event *signal_event = evsignal_new(program.eventbase, SIGINT, signal_cb, &program); evsignal_add(signal_event, NULL); /* Create a server */ bp_server_s server; program.server = &server; bp_server_init(&server, &program, (char*)&sockaddr.sin6_addr, ntohs(sockaddr.sin6_port)); if (bp_server_listen(&server, listen_port) < 0) { return EXIT_FAILURE; } /* We need to connect to one initial node in order to seed everything. We will not do this initial discovery ourselves. */ for (int i = 0; i < nodecount; i++) { bp_connection_s *seed_connection = malloc(sizeof(bp_connection_s)); int status = bp_connection_connect(seed_connection, &server, &nodeaddrs[i], nodelens[i]); if (status < 0) { printf("Connecting failed\n"); } seed_connection->is_seed = 1; seed_connection->is_permanent = nodeperm[i]; } free(nodeaddrs); free(nodelens); free(nodeperm); /* Run the loop */ event_base_loop(program.eventbase, 0); printf("Entering clean shutdown state\n"); /* It would appear that our loop ended, so clean up */ event_free(signal_event); bp_server_deinit(&server); bp_program_deinit(&program); event_base_free(program.eventbase); return EXIT_SUCCESS; }
//----------------------------------------------------------------------------- // callback function that will fire when the connection to the controller is reached. static void controller_connect_handler(int fd, short int flags, void *arg) { controller_t *ct = (controller_t *) arg; node_t *node; system_data_t *sysdata; queue_t *q; int error; socklen_t foo; struct timeval t = {.tv_sec = 1, .tv_usec = 0}; short int exclusive; assert(fd >= 0); assert(flags != 0); assert(ct); assert(ct->node == NULL); assert(ct->target); assert(ct->sysdata); sysdata = ct->sysdata; // we only need to detect EV_WRITE for a connect event. assert(flags == EV_WRITE); // remove the connect event assert(ct->connect_event); event_free(ct->connect_event); ct->connect_event = NULL; // we are no longer connected. We are either connected, or not. assert(BIT_TEST(ct->flags, FLAG_CONTROLLER_CONNECTING)); BIT_CLEAR(ct->flags, FLAG_CONTROLLER_CONNECTING); // check to see if we really are connected. foo = sizeof(error); getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &foo); if (error == ECONNREFUSED) { // we were connecting, but couldn't. BIT_SET(ct->flags, FLAG_CONTROLLER_CLOSED); // close the socket that didn't connect. close(fd); //set the action so that we can attempt to reconnect. assert(ct->connect_event == NULL); assert(sysdata->evbase); ct->connect_event = evtimer_new(sysdata->evbase, controller_wait_handler, (void *) ct); evtimer_add(ct->connect_event, &t); } else { logger(((system_data_t *)ct->sysdata)->logging, 2, "connected to remote controller: %s", ct->target); // create the node object. node = node_create(sysdata, fd); // add node to the main nodes list. ct->node = node; assert(node->controller == NULL); node->controller = ct; BIT_SET(node->flags, FLAG_NODE_CONTROLLER); // we need to check to see if we have any queues with active consumers, // and if we do, then we need to send consume requests to this node for // each one. assert(sysdata->queues); ll_start(sysdata->queues); while ((q = ll_next(sysdata->queues))) { assert(q->qid > 0); assert(q->name); if (ll_count(&q->nodes_busy) > 0 || ll_count(&q->nodes_ready) > 0) { logger(((system_data_t *)ct->sysdata)->logging, 2, "Sending queue consume ('%s') to alternate controller at %s", q->name, ct->target ); exclusive = 0; if (BIT_TEST(q->flags, QUEUE_FLAG_EXCLUSIVE)) exclusive = 1; sendConsume(node, q->name, 1, RQ_PRIORITY_LOW, exclusive); ll_push_head(&q->nodes_consuming, node); } } ll_finish(sysdata->queues); } } void controller_connect(controller_t *ct) { evutil_socket_t sock; int result; int len; assert(ct); assert(ct->target); assert(ct->node == NULL); assert(BIT_TEST(ct->flags, FLAG_CONTROLLER_CONNECTED) == 0); assert(BIT_TEST(ct->flags, FLAG_CONTROLLER_FAILED) == 0); assert(BIT_TEST(ct->flags, FLAG_CONTROLLER_CONNECTING) == 0); // if not already resolved.... resolve the target. if (BIT_TEST(ct->flags, FLAG_CONTROLLER_RESOLVED) == 0) { assert(ct->flags == 0); logger(((system_data_t *)ct->sysdata)->logging, 3, "resolving controller %s.", ct->target); len = sizeof(ct->saddr); if (evutil_parse_sockaddr_port(ct->target, &ct->saddr, &len) == 0) { BIT_SET(ct->flags, FLAG_CONTROLLER_RESOLVED); } else { BIT_SET(ct->flags, FLAG_CONTROLLER_FAILED); } } if (BIT_TEST(ct->flags, FLAG_CONTROLLER_FAILED) == 0) { assert(BIT_TEST(ct->flags, FLAG_CONTROLLER_RESOLVED)); BIT_SET(ct->flags, FLAG_CONTROLLER_CONNECTING); sock = socket(AF_INET,SOCK_STREAM,0); assert(sock >= 0); // Before we attempt to connect, set the socket to non-blocking mode. evutil_make_socket_nonblocking(sock); logger(((system_data_t *)ct->sysdata)->logging, 3, "Attempting Remote connect to %s.", ct->target); result = connect(sock, &ct->saddr, sizeof(struct sockaddr)); assert(result < 0); assert(errno == EINPROGRESS); // connect process has been started. Now we need to create an event so that we know when the connect has completed. assert(ct->connect_event == NULL); assert(ct->sysdata); assert(((system_data_t *)ct->sysdata)->evbase); ct->connect_event = event_new(((system_data_t *)ct->sysdata)->evbase, sock, EV_WRITE, controller_connect_handler, ct); event_add(ct->connect_event, NULL); } else { assert(ct->target); logger(((system_data_t *)ct->sysdata)->logging, 2, "Remote connect to %s has failed.", ct->target); } }
int main(int argc, char **argv) { int i; int socklen; int use_ssl = 0; struct evconnlistener *listener; if (argc < 3) syntax(); for (i=1; i < argc; ++i) { if (!strcmp(argv[i], "-s")) { use_ssl = 1; } else if (!strcmp(argv[i], "-W")) { use_wrapper = 0; } else if (argv[i][0] == '-') { syntax(); } else break; } if (i+2 != argc) syntax(); memset(&listen_on_addr, 0, sizeof(listen_on_addr)); socklen = sizeof(listen_on_addr); if (evutil_parse_sockaddr_port(argv[i], (struct sockaddr*)&listen_on_addr, &socklen)<0) { int p = atoi(argv[i]); struct sockaddr_in *sin = (struct sockaddr_in*)&listen_on_addr; if (p < 1 || p > 65535) syntax(); sin->sin_port = htons(p); sin->sin_addr.s_addr = htonl(0x7f000001); sin->sin_family = AF_INET; socklen = sizeof(struct sockaddr_in); } memset(&connect_to_addr, 0, sizeof(connect_to_addr)); connect_to_addrlen = sizeof(connect_to_addr); if (evutil_parse_sockaddr_port(argv[i+1], (struct sockaddr*)&connect_to_addr, &connect_to_addrlen)<0) syntax(); base = event_base_new(); if (!base) { perror("event_base_new()"); return 1; } if (use_ssl) { int r; SSL_library_init(); ERR_load_crypto_strings(); SSL_load_error_strings(); OpenSSL_add_all_algorithms(); r = RAND_poll(); if (r == 0) { fprintf(stderr, "RAND_poll() failed.\n"); return 1; } ssl_ctx = SSL_CTX_new(SSLv23_method()); } listener = evconnlistener_new_bind(base, accept_cb, NULL, LEV_OPT_CLOSE_ON_FREE|LEV_OPT_CLOSE_ON_EXEC|LEV_OPT_REUSEABLE, -1, (struct sockaddr*)&listen_on_addr, socklen); if (! listener) { fprintf(stderr, "Couldn't open listener.\n"); event_base_free(base); return 1; } event_base_dispatch(base); evconnlistener_free(listener); event_base_free(base); return 0; }
int main(int argc, char **argv) { int socklen; struct evconnlistener *listener; if (argc < 2) { syntax(); } adapter = ssh_adapter_new(); if(adapter == NULL) { trace_err("ssh_adapter create failed."); return 0x01; } //ssh_adapter_options_set(adapter, SSH_BIND_OPTIONS_HOSTKEY, xKEYS_FOLDER "ssh_host_key"); ssh_adapter_options_set(adapter, SSH_BIND_OPTIONS_DSAKEY, xKEYS_FOLDER "ssh_host_dsa_key"); ssh_adapter_options_set(adapter, SSH_BIND_OPTIONS_RSAKEY, xKEYS_FOLDER "ssh_host_rsa_key"); ssh_adapter_options_set(adapter, SSH_BIND_OPTIONS_LOG_VERBOSITY_STR, "4"); ssh_adapter_init(adapter); memset(&listen_on_addr, 0, sizeof(listen_on_addr)); socklen = sizeof(listen_on_addr); if (evutil_parse_sockaddr_port(argv[1], (struct sockaddr*)&listen_on_addr, &socklen)<0) { int p = atoi(argv[1]); struct sockaddr_in *sin = (struct sockaddr_in*)&listen_on_addr; if (p < 1 || p > 65535) { syntax(); } sin->sin_port = htons(p); sin->sin_addr.s_addr = htonl(0x7f000001); sin->sin_family = AF_INET; socklen = sizeof(struct sockaddr_in); } memset(&connect_to_addr, 0, sizeof(connect_to_addr)); connect_to_addrlen = sizeof(connect_to_addr); if (evutil_parse_sockaddr_port(argv[2], (struct sockaddr*)&connect_to_addr, &connect_to_addrlen)<0) { syntax(); } base = event_base_new(); if (!base) { perror("event_base_new()"); return 1; } listener = evconnlistener_new_bind(base, accept_cb, NULL, LEV_OPT_CLOSE_ON_FREE|LEV_OPT_CLOSE_ON_EXEC|LEV_OPT_REUSEABLE, -1, (struct sockaddr*)&listen_on_addr, socklen); if (!listener) { fprintf(stderr, "Couldn't open listener.\n"); event_base_free(base); return 1; } event_base_dispatch(base); evconnlistener_free(listener); event_base_free(base); return 0; }
/** @return a string representing the address and port to connect to. */ static String* initAngel(int fromAngel, int toAngel, int corePipes[2][2], struct PipeInterface** piOut, struct EventBase* eventBase, struct Log* logger, struct Allocator* alloc, struct Random* rand) { #define TO_CORE (corePipes[0][1]) #define FROM_CORE (corePipes[1][0]) #define TO_ANGEL_AS_CORE (corePipes[1][1]) #define FROM_ANGEL_AS_CORE (corePipes[0][0]) Dict core = Dict_CONST( String_CONST("fromCore"), Int_OBJ(FROM_CORE), Dict_CONST( String_CONST("toCore"), Int_OBJ(TO_CORE), NULL )); Dict admin = Dict_CONST( String_CONST("bind"), String_OBJ(String_CONST("127.0.0.1")), Dict_CONST( String_CONST("core"), Dict_OBJ(&core), Dict_CONST( String_CONST("pass"), String_OBJ(String_CONST("abcd")), NULL ))); Dict message = Dict_CONST( String_CONST("admin"), Dict_OBJ(&admin), NULL ); struct Allocator* tempAlloc; BufferAllocator_STACK(tempAlloc, 1024); #define BUFFER_SZ 1023 uint8_t buff[BUFFER_SZ + 1] = {0}; struct Writer* w = ArrayWriter_new(buff, BUFFER_SZ, tempAlloc); StandardBencSerializer_get()->serializeDictionary(w, &message); Log_info(logger, "Writing intial configuration to angel on [%d] config: [%s]", toAngel, buff); write(toAngel, buff, w->bytesWritten(w)); // This is angel->core data, we can throw this away. //Waiter_getData(buff, BUFFER_SZ, fromAngel, eventBase, NULL); //Log_info(logger, "Init message from angel to core: [%s]", buff); Bits_memset(buff, 0, BUFFER_SZ); struct PipeInterface* pi = PipeInterface_new(FROM_ANGEL_AS_CORE, TO_ANGEL_AS_CORE, eventBase, logger, alloc, rand); *piOut = pi; Log_info(logger, "PipeInterface [%p] is now ready.", (void*)pi); // Make sure the angel sends data to the core. InterfaceWaiter_waitForData(&pi->generic, eventBase, alloc, NULL); // Send response on behalf of core. char coreToAngelResponse[128] = " PADDING " "\xff\xff\xff\xff" "d" "5:error" "4:none" "e"; char* start = strchr(coreToAngelResponse, '\xff'); struct Message m = { .bytes = (uint8_t*) start, .length = strlen(start), .padding = start - coreToAngelResponse }; pi->generic.sendMessage(&m, &pi->generic); // This is angel->client data, it will tell us which port was bound. Waiter_getData(buff, BUFFER_SZ, fromAngel, eventBase, NULL); printf("Response from angel to client: [%s]\n", buff); struct Reader* reader = ArrayReader_new(buff, BUFFER_SZ, tempAlloc); Dict configStore; Dict* config = &configStore; Assert_true(!StandardBencSerializer_get()->parseDictionary(reader, tempAlloc, config)); Dict* responseAdmin = Dict_getDict(config, String_CONST("admin")); String* bind = Dict_getString(responseAdmin, String_CONST("bind")); Assert_true(bind); return String_clone(bind, alloc); } /** * This spawns itself as the Angel process which spawns itself again as the core process. * The "core process" pipes all of its inputs back to the originating process */ struct AdminTestFramework* AdminTestFramework_setUp(int argc, char** argv) { if (argc > 1 && !strcmp("angel", argv[1])) { exit(AngelInit_main(argc, argv)); } struct Allocator* alloc = CanaryAllocator_new(MallocAllocator_new(1<<20), NULL); struct Writer* logwriter = FileWriter_new(stdout, alloc); Assert_always(logwriter); struct Log* logger = WriterLog_new(logwriter, alloc); struct EventBase* eventBase = EventBase_new(alloc); struct Random* rand = Random_new(alloc, NULL); int fromAngel; int toAngel; int corePipes[2][2]; if (Pipe_createUniPipe(corePipes[0]) || Pipe_createUniPipe(corePipes[1])) { Except_raise(NULL, -1, "Failed to create pipes [%s]", Errno_getString()); } spawnAngel(&fromAngel, &toAngel); struct PipeInterface* pi; String* addrStr = initAngel(fromAngel, toAngel, corePipes, &pi, eventBase, logger, alloc, rand); Log_info(logger, "Angel initialized."); String* password = String_new("abcd", alloc); struct Admin* admin = Admin_new(&pi->generic, alloc, logger, eventBase, password); // Now setup the client. struct sockaddr_storage addr; int addrLen = sizeof(struct sockaddr_storage); Bits_memset(&addr, 0, sizeof(struct sockaddr_storage)); Assert_true(!evutil_parse_sockaddr_port(addrStr->bytes, (struct sockaddr*) &addr, &addrLen)); struct AdminClient* client = AdminClient_new((uint8_t*) &addr, addrLen, password, eventBase, logger, alloc); Assert_always(client); return alloc->clone(sizeof(struct AdminTestFramework), alloc, &(struct AdminTestFramework) { .admin = admin, .client = client, .alloc = alloc, .eventBase = eventBase, .logger = logger, .addr = alloc->clone(addrLen, alloc, &addr), .addrLen = addrLen, .angelInterface = &pi->generic }); }
static void echo_read_cb(struct bufferevent *bev, void *ctx) { printf("echo_read_cb ctx:%p\n", ctx); /* This callback is invoked when there is data to read on bev. */ struct evbuffer *input = bufferevent_get_input(bev); /* Copy all the data from the input buffer to the output buffer. */ // evbuffer_add_buffer(output, input); // 能读到数据的时候 去连接其他server 而且是以阻塞的方式 printf("echo_read_cb1 \n"); struct sockaddr_in servaddr; memset(&servaddr, 0, sizeof(servaddr)); //servaddr.sin_family = AF_INET; ////servaddr.sin_addr.s_addr = htonl(0x7f000001); /* 127.0.0.1 */ //if (inet_aton("192.168.1.104", &servaddr.sin_addr) == 0) //{ // perror("inet_aton failure!"); // printf("address:%u\n", servaddr.sin_addr.s_addr); // exit(EXIT_FAILURE); //} //servaddr.sin_port = htons(5188); /* Port 9876*/ // TODO 错误判断 char buff[64]; evutil_snprintf(buff, sizeof(buff), "%s:%d", "192.168.1.104", 5188); int servadd_len = sizeof(servaddr); //int retx = evutil_parse_sockaddr_port("192.168.1.104:5188", (struct sockaddr*)&servaddr, &servadd_len); int retx = evutil_parse_sockaddr_port(buff, (struct sockaddr*)&servaddr, &servadd_len); printf("address:%s\n", buff); if (retx < 0) { printf("address:error\n"); } else { printf("address:%u\n", servaddr.sin_addr.s_addr); } int sockconn; errno = 0; if ((sockconn = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) { perror("socket failure"); exit(EXIT_FAILURE); } //evutil_make_socket_nonblocking(sockconn); struct timeval tv; tv.tv_sec = 5; tv.tv_usec = 0; setsockopt(sockconn, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); setsockopt(sockconn, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)); // bufferevent_socket_new 只是分配内存 没有系统调用 struct bufferevent *bev1 = bufferevent_socket_new(ctx, sockconn, BEV_OPT_CLOSE_ON_FREE); //bufferevent_settimeout(bev1, 10, 10); //bev1 = bufferevent_socket_new(ctx, -1, BEV_OPT_CLOSE_ON_FREE); bufferevent_enable(bev1, EV_READ|EV_WRITE); bufferevent_setcb(bev1, NULL, NULL, eventcb, "hello"); //SetSocketBlockingEnabled(sockconn, 1); // 这里默认是阻塞的,会一直阻塞 直到连接成功 或超时 // // if (bufferevent_socket_connect(bev1, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) { /* Error starting connection */ // 连接不能马上建立的时候 应该添加到写事件中 fprintf(stderr, "Connect failed.\n"); perror("connect..........."); //#define ETIMEDOUT 110 /* Connection timed out */ // 无条件超时 非自定义超时 走这里// //bufferevent_free(bev1); // 此时错误码是 BEV_EVENT_ERROR 在那里销毁 BEV_EVENT_ERROR //return -1; // 110错误码走到这里 11, 115错误码 不会走到这里 } printf("bufferevent_socket_connect return errno:%d \n", errno); ////#define EAGAIN 11 /* Try again */ ////#define ECONNREFUSED 111 /* Connection refused */ ////#define EINPROGRESS 115 /* Operation now in progress */ // connect 被超时打断11, // //if (errno != EAGAIN ) if (errno == EINPROGRESS) // 自定义 超时中断 { perror("self timeout............."); bufferevent_free(bev1); return; } else if (errno != 0) { perror("00buffevent_connect"); printf("bufferevent_socket_connect error\n"); //如果 在过程中 超时会被 打断 EINPROGRESS 115 /* Operation now in progress */ // 除了自定义超时timeout不宜在这里销毁 在 回调函数中销毁 不然调用不到回调函数// //bufferevent_free(bev1); return ; } else { // 连接成功 perror("11buffevent_connect"); printf("bufferevent_socket_connect success\n"); } //if (connect(sockconn, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0) //{ // perror("connnect error"); // exit(EXIT_FAILURE); //} //else //{ // printf("connect success\n"); //} //char recvbuf[1024] = {0}; //memset(recvbuf, 0, sizeof(recvbuf)); //sleep(5); //read(sockconn, recvbuf, sizeof(recvbuf)); //printf("----%s-----\n", recvbuf); // struct evbuffer *input1 = bufferevent_get_input(bev1); // printf("before read ---------\n"); // bufferevent_read_buffer(bev1, input1); // size_t len = evbuffer_get_length(input1); // unsigned char * recvbuf = evbuffer_pullup(input1, len); // printf("end read len:%ld---------\n", len); // printf("----%s-----\n", recvbuf); //struct evbuffer * buffer = evbuffer_new(); struct evbuffer *buffer = bufferevent_get_input(bev1); struct evbuffer *buffero = bufferevent_get_output(bev1); evutil_socket_t fd = bufferevent_getfd(bev1); time_t rawtime; time ( &rawtime ); printf("before read ---------%ld\n", rawtime); int ret = evbuffer_read(buffer, fd, 1024); // not work // bufferevent_read_buffer(bev1, buffer); size_t len = evbuffer_get_length(buffer); time ( &rawtime ); printf("end readlen ---------%ld\n", len); unsigned char * recvbuf = evbuffer_pullup(buffer, len); printf("end read ---------%ld\n", rawtime); printf("----%s-----\n", recvbuf); evbuffer_drain(buffer, len); // int evbuffer_write(struct evbuffer *buffer, evutil_socket_t fd); time ( &rawtime ); printf("before write---------%ld\n", rawtime); sleep(10); time ( &rawtime ); printf("before write1---------%ld\n", rawtime); evbuffer_add(buffero, "hello,china", 12); ret = evbuffer_write(buffero, fd); // ret =write(fd, "hello,china", 12); if (ret < 0) { if (errno != 0) { perror("write "); } } time ( &rawtime ); printf("end write1 ---------%ld\n", rawtime); // 出现read 在connect 之前// //root@debian:~/programming/libevent/libevent2/libevent/sample/study-buffevent_block# ./echoserver_block // create listener success, base:0xfdbc40 // echo_read_cb ctx:0xfdbc40 // echo_read_cb1 // bufferevent_socket_connect return errno:11 // 11buffevent_connect: Resource temporarily unavailable // bufferevent_socket_connect success // ----hello,world----- // Connect okay,-------------------------- hello. // disConnect --------------------------. }
int imap_driver_init(struct module *module, struct event_base *base) { struct imap_driver *driver = module->priv; struct imap_config *config; struct imap_handler *handler = handlers; struct module *ldap; struct sockaddr_in6 sin; int socklen = sizeof(sin); assert(driver && driver->config && base); config = driver->config; driver->base = base; driver->dnsbase = get_dnsbase(); if (config->cert) { driver->ssl_ctx = new_ssl_ctx(config->cert, config->pkey); if (driver->ssl_ctx == NULL) { return 1; } } else { /* skip the STARTTLS handler */ handler += 1; } for (; handler->command; handler++) { /* handle the private handler storage */ if (avl_insert(&driver->commands, handler, imap_handler_cmp, avl_dup_error)) { return 1; } } if (evutil_parse_sockaddr_port(config->listen, (struct sockaddr *)&sin, &socklen)) { return 1; } /* we start in disabled state until the LDAP interface is ready */ driver->listener = evconnlistener_new_bind(base, listen_cb, (void*)driver, LEV_OPT_REUSEABLE|LEV_OPT_DISABLED|LEV_OPT_CLOSE_ON_FREE, -1, (struct sockaddr *)&sin, socklen); /* could also be wise to set an error callback, but what errors do we face * on accept()? */ if (!driver->listener) { skeeter_log(LOG_CRIT, "Could not create a listener!"); return 1; } ldap = get_module("ldap"); if (!ldap || !ldap->register_event) { skeeter_log(LOG_CRIT, "LDAP module not available!"); return 1; } if (ldap->register_event(ldap, MODULE_ANY | MODULE_PERSIST, trigger_listener, driver->listener)) { skeeter_log(LOG_CRIT, "Regitration with LDAP module failed!"); return 1; } driver->ldap = ldap; return 0; }
int main(int argc, char** argv) { #ifdef Log_KEYS fprintf(stderr, "Log_LEVEL = KEYS, EXPECT TO SEE PRIVATE KEYS IN YOUR LOGS!\n"); #endif Assert_true(argc > 0); struct Except* eh = NULL; // Allow it to allocate 4MB struct Allocator* allocator = MallocAllocator_new(1<<22); struct Random* rand = Random_new(allocator, eh); struct EventBase* eventBase = EventBase_new(allocator); if (argc == 2) { // one argument if (strcmp(argv[1], "--help") == 0) { return usage(argv[0]); } else if (strcmp(argv[1], "--genconf") == 0) { return genconf(rand); } else if (strcmp(argv[1], "--pidfile") == 0) { // Performed after reading the configuration } else if (strcmp(argv[1], "--reconf") == 0) { // Performed after reading the configuration } else if (strcmp(argv[1], "--bench") == 0) { return benchmark(); } else if (strcmp(argv[1], "--version") == 0) { //printf("Version ID: %s\n", RouterModule_gitVersion()); return 0; } else { fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], argv[1]); fprintf(stderr, "Try `%s --help' for more information.\n", argv[0]); return -1; } } else if (argc > 2) { // more than one argument? fprintf(stderr, "%s: too many arguments\n", argv[0]); fprintf(stderr, "Try `%s --help' for more information.\n", argv[0]); return -1; } if (isatty(STDIN_FILENO)) { // We were started from a terminal // The chances an user wants to type in a configuration // bij hand are pretty slim so we show him the usage return usage(argv[0]); } else { // We assume stdin is a configuration file and that we should // start routing } struct Reader* stdinReader = FileReader_new(stdin, allocator); Dict config; if (JsonBencSerializer_get()->parseDictionary(stdinReader, allocator, &config)) { fprintf(stderr, "Failed to parse configuration.\n"); return -1; } struct Writer* logWriter = FileWriter_new(stdout, allocator); struct Log* logger = WriterLog_new(logWriter, allocator); // --------------------- Setup Pipes to Angel --------------------- // int pipeToAngel[2]; int pipeFromAngel[2]; if (Pipe_createUniPipe(pipeToAngel) || Pipe_createUniPipe(pipeFromAngel)) { Except_raise(eh, -1, "Failed to create pipes to angel [%s]", Errno_getString()); } char pipeToAngelStr[8]; snprintf(pipeToAngelStr, 8, "%d", pipeToAngel[0]); char pipeFromAngelStr[8]; snprintf(pipeFromAngelStr, 8, "%d", pipeFromAngel[1]); char* args[] = { "angel", pipeToAngelStr, pipeFromAngelStr, NULL }; // --------------------- Spawn Angel --------------------- // String* corePath = Dict_getString(&config, String_CONST("corePath")); String* privateKey = Dict_getString(&config, String_CONST("privateKey")); if (!corePath) { corePath = getCorePath(allocator); if (!corePath) { Except_raise(eh, -1, "Can't find a usable cjdns core executable, " "try specifying the location in your cjdroute.conf"); } else { Log_warn(logger, "Cjdns core executable was not specified in cjdroute.conf, " "guessing its location."); } } if (!privateKey) { Except_raise(eh, -1, "Need to specify privateKey."); } Log_info(logger, "Forking angel to background."); Process_spawn(corePath->bytes, args); // --------------------- Get Admin --------------------- // Dict* configAdmin = Dict_getDict(&config, String_CONST("admin")); String* adminPass = Dict_getString(configAdmin, String_CONST("password")); String* adminBind = Dict_getString(configAdmin, String_CONST("bind")); if (!adminPass) { adminPass = String_newBinary(NULL, 32, allocator); Random_base32(rand, (uint8_t*) adminPass->bytes, 32); adminPass->len = strlen(adminPass->bytes); } if (!adminBind) { adminBind = String_new("127.0.0.1:0", allocator); } // --------------------- Get user for angel to setuid() ---------------------- // String* securityUser = NULL; List* securityConf = Dict_getList(&config, String_CONST("security")); for (int i = 0; i < List_size(securityConf); i++) { securityUser = Dict_getString(List_getDict(securityConf, i), String_CONST("setuser")); if (securityUser) { break; } } // --------------------- Pre-Configure Angel ------------------------- // Dict* preConf = Dict_new(allocator); Dict* adminPreConf = Dict_new(allocator); Dict_putDict(preConf, String_CONST("admin"), adminPreConf, allocator); Dict_putString(adminPreConf, String_CONST("core"), corePath, allocator); Dict_putString(preConf, String_CONST("privateKey"), privateKey, allocator); Dict_putString(adminPreConf, String_CONST("bind"), adminBind, allocator); Dict_putString(adminPreConf, String_CONST("pass"), adminPass, allocator); if (securityUser) { Dict_putString(adminPreConf, String_CONST("user"), securityUser, allocator); } #define CONFIG_BUFF_SIZE 1024 uint8_t buff[CONFIG_BUFF_SIZE] = {0}; struct Writer* toAngelWriter = ArrayWriter_new(buff, CONFIG_BUFF_SIZE - 1, allocator); if (StandardBencSerializer_get()->serializeDictionary(toAngelWriter, preConf)) { Except_raise(eh, -1, "Failed to serialize pre-configuration"); } write(pipeToAngel[1], buff, toAngelWriter->bytesWritten(toAngelWriter)); Log_keys(logger, "Sent [%s] to angel process.", buff); // --------------------- Get Response from Angel --------------------- // uint32_t amount = Waiter_getData(buff, CONFIG_BUFF_SIZE, pipeFromAngel[0], eventBase, eh); Dict responseFromAngel; struct Reader* responseFromAngelReader = ArrayReader_new(buff, amount, allocator); if (StandardBencSerializer_get()->parseDictionary(responseFromAngelReader, allocator, &responseFromAngel)) { Except_raise(eh, -1, "Failed to parse pre-configuration response [%s]", buff); } // --------------------- Get Admin Addr/Port/Passwd --------------------- // Dict* responseFromAngelAdmin = Dict_getDict(&responseFromAngel, String_CONST("admin")); adminBind = Dict_getString(responseFromAngelAdmin, String_CONST("bind")); struct sockaddr_storage adminAddr; Bits_memset(&adminAddr, 0, sizeof(struct sockaddr_storage)); int adminAddrLen = sizeof(struct sockaddr_storage); if (!adminBind) { Except_raise(eh, -1, "didn't get address and port back from angel"); } if (evutil_parse_sockaddr_port(adminBind->bytes, (struct sockaddr*) &adminAddr, &adminAddrLen)) { Except_raise(eh, -1, "Unable to parse [%s] as an ip address port, eg: 127.0.0.1:11234", adminBind->bytes); } // --------------------- Configuration ------------------------- // Configurator_config(&config, (uint8_t*)&adminAddr, adminAddrLen, adminPass, eventBase, logger, allocator); return 0; }
int main (int argc, char **argv) { int i, socklen, erroffset, options = 0; pfilter_info pfi = NULL; pattern * p; struct evconnlistener * listener; const char * error; const unsigned char * re_tables = NULL; if (argc < 3) syntax (); for (i = 1; i < argc; ++i) { if (!strcmp (argv[i], "-l")) { callback_info::logging = true; ++i; if (i > argc) { syntax (); break; } strncpy (logfile, argv[i], MY_MAX_PATH); logfile[MY_MAX_PATH - 1] = '\0'; printf ("Logging to: %s enabled\n", logfile); } else if (!strcmp (argv[i], "-r")) { callback_info::filtering = true; ++i; if (i > argc) { syntax (); break; } strncpy (regexp, argv[i], MY_MAX_PATH); regexp[MY_MAX_PATH - 1] = '\0'; printf ("Regexp: %s added to filter chain\n", regexp); if (!pfi) { pfi = (pfilter_info) malloc (sizeof (filter_info)); callback_info::pfi = pfi; pfi->patterns = new std::vector < ppattern >; } p = new pattern; p->raw_pattern = regexp; re_tables = pcre_maketables (); p->re = pcre_compile (regexp, options, &error, &erroffset, NULL); p->extra_re = pcre_study (p->re, 0, &error); if (!p->re || !p->extra_re) syntax (); callback_info::pfi->patterns->push_back (p); } else break; } if (i + 2 != argc) syntax (); #ifdef WIN32 WORD wVersionRequested; WSADATA wsaData; int err; wVersionRequested = MAKEWORD (2, 2); err = WSAStartup (wVersionRequested, &wsaData); if (err != 0) { printf ("WSAStartup failed with error: %d\n", err); return 1; } #endif memset (&listen_on_addr, 0, sizeof (listen_on_addr)); socklen = sizeof (listen_on_addr); if (evutil_parse_sockaddr_port (argv[i], (struct sockaddr *) &listen_on_addr, &socklen) < 0) { int p = atoi (argv[i]); struct sockaddr_in * sin = (struct sockaddr_in *) &listen_on_addr; if (p < 1 || p > 65535) syntax (); sin->sin_port = htons (p); sin->sin_addr.s_addr = htonl (0x7f000001); sin->sin_family = AF_INET; socklen = sizeof (struct sockaddr_in); } memset (&connect_to_addr, 0, sizeof (connect_to_addr)); connect_to_addrlen = sizeof (connect_to_addr); if (evutil_parse_sockaddr_port (argv[i + 1], (struct sockaddr *) &connect_to_addr, &connect_to_addrlen) < 0) syntax (); if (callback_info::logging) { if (!(callback_info::fd_out = fopen (logfile, "wb"))) { syntax (); } } base = event_base_new (); if (!base) { perror ("event_base_new()"); return 1; } listener = evconnlistener_new_bind (base, accept_cb, NULL, LEV_OPT_CLOSE_ON_FREE | LEV_OPT_CLOSE_ON_EXEC | LEV_OPT_REUSEABLE, -1, (struct sockaddr *) &listen_on_addr, socklen); event_base_dispatch (base); if (callback_info::logging) { fclose (callback_info::fd_out); } if (callback_info::filtering) { callback_info::pfi->patterns->~vector (); free (callback_info::pfi); } evconnlistener_free (listener); event_base_free (base); return 0; }
struct Interface* insertEndpoint(struct sockaddr_storage* addr, struct UDPInterface* context) { if (context->endpointCount >= MAX_INTERFACES) { return NULL; } struct Allocator* epAllocator = context->allocator->child(context->allocator); struct Endpoint* ep = &context->endpoints[context->endpointCount]; memcpy(&ep->addr, addr, sizeof(struct sockaddr_storage)); struct Interface iface = { .senderContext = context, .sendMessage = sendMessage, .allocator = epAllocator, .maxMessageLength = MAX_PACKET_SIZE, .requiredPadding = 0 }; memcpy(&ep->interface, &iface, sizeof(struct Interface)); epAllocator->onFree(closeInterface, &ep->interface, epAllocator); context->addresses[context->endpointCount] = getAddr(addr); context->endpointCount++; return &ep->interface; } struct Interface* UDPInterface_addEndpoint(struct UDPInterface* context, const char* endpointSockAddr, struct ExceptionHandler* exHandler) { struct sockaddr_storage addr; int addrLen = sizeof(struct sockaddr_storage); if (0 != evutil_parse_sockaddr_port(endpointSockAddr, (struct sockaddr*) &addr, &addrLen)) { exHandler->exception(__FILE__ " UDPInterface_addEndpoint() failed to parse address.", -1, exHandler); return NULL; } if (addrLen != context->addrLen) { // You can't just bind to an ip4 address then start sending ip6 traffic exHandler->exception(__FILE__ " UDPInterface_addEndpoint() address of different type " "then interface.", -1, exHandler); return NULL; } return insertEndpoint(&addr, context); } struct Interface* UDPInterface_getDefaultInterface(struct UDPInterface* context) { if (context->defaultInterface == NULL) { struct sockaddr_storage sockaddrZero; memset(&sockaddrZero, 0, sizeof(struct sockaddr_storage)); context->defaultInterface = insertEndpoint(&sockaddrZero, context); } return context->defaultInterface; } int UDPInterface_bindToCurrentEndpoint(struct Interface* defaultInterface) { struct UDPInterface* context = (struct UDPInterface*) defaultInterface->senderContext; if (context->defaultInterface != defaultInterface || context->defaultInterfaceSender == NULL) { return -1; } for (uint32_t i = 0; i < context->endpointCount; i++) { // TODO this can be faster if (defaultInterface == &context->endpoints[i].interface) { struct Endpoint* ep = &context->endpoints[i]; memcpy(&ep->addr, context->defaultInterfaceSender, sizeof(struct sockaddr_storage)); context->addresses[i] = getAddr(&ep->addr); context->defaultInterface = NULL; return 0; } } assert(!"Couldn't find the interface in the list"); } /*--------------------Internals--------------------*/ /** * Release the event used by this module. * * @param vevent a void pointer cast of the event structure. */ static void freeEvent(void* vevent) { event_del((struct event*) vevent); event_free((struct event*) vevent); }
int obfsproxyssh_client_init(obfsproxyssh_t *state) { obfsproxyssh_client_t *client; struct sockaddr_storage addr; evutil_socket_t sock; uint16_t port; int rval, len; client = calloc(1, sizeof(obfsproxyssh_client_t)); if (NULL == client) { fprintf(stdout, "CMETHOD-ERROR %s Out of memory allocating state\n", OBFSPROXYSSH_METHOD); return -1; } client->state = state; memset(&addr, 0, sizeof(addr)); len = sizeof(addr); evutil_parse_sockaddr_port(OBFSPROXYSSH_CLIENT_BIND_ADDR ":8080", (struct sockaddr *) &addr, &len); ((struct sockaddr_in *) &addr)->sin_port = 0; /* Use ephemeral port */ client->listener = evconnlistener_new_bind(state->base, socks_accept_cb, client, LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, -1, (struct sockaddr *) &addr, len); if (NULL == client->listener) { fprintf(stdout, "CMETHOD-ERROR %s Failed to bind SOCKS socket\n", OBFSPROXYSSH_METHOD); goto out_error; } evconnlistener_set_error_cb(client->listener, client_error_cb); sock = evconnlistener_get_fd(client->listener); len = sizeof(addr); rval = getsockname(sock, (struct sockaddr *) &addr, (socklen_t *) &len); if (rval) { fprintf(stdout, "CMETHOD-ERROR %s Failed to get SOCKS socket addr %d\n", OBFSPROXYSSH_METHOD, rval); goto out_free_listener; } port = htons(((struct sockaddr_in *) &addr)->sin_port); rval = libssh2_init(0); if (rval) { fprintf(stdout, "CMETHOD-ERROR %s Failed to initialize libssh2 (%d)\n", OBFSPROXYSSH_METHOD, rval); goto out_free_listener; } rval = ssh_client_profile_init(client); if (rval) { fprintf(stdout, "CMETHOD-ERROR %s Failed to initialize libssh2 algorithms (%d)\n", OBFSPROXYSSH_METHOD, rval); goto out_free_listener; } if (0 == state->unsafe_logging) log_f(state, "SOCKS: Listening on: TCP port %d", port); else log_f(state, "SOCKS: Listening on: %s:%d", OBFSPROXYSSH_CLIENT_BIND_ADDR, port); fprintf(stdout, "CMETHOD %s socks4 %s:%d %s\n", OBFSPROXYSSH_METHOD, OBFSPROXYSSH_CLIENT_BIND_ADDR, port, OBFSPROXYSSH_CLIENT_CMETHOD_ARGS); LIST_INIT(&client->sessions); LIST_INIT(&client->arg_cache); state->ctxt = client; state->shutdown_fn = client_on_shutdown; return 0; out_free_listener: evconnlistener_free(client->listener); out_error: free(client); return -1; }