void *socket_http_listener() { prctl(PR_SET_NAME, (char *)"HTTP", 0, 0, 0); while (1){ struct client_ctx *cc = socket_listen(&srv_http); if (!cc) continue; struct lnode *n = calloc(sizeof(*n), 1); queue_push(n, cc); } pthread_exit(0); }
/*-------------------------------------------------------------------------*\ * Puts the sockt in listen mode \*-------------------------------------------------------------------------*/ static int meth_listen(lua_State *L) { p_tcp tcp = (p_tcp) auxiliar_checkclass(L, "tcp{master}", 1); int backlog = (int) luaL_optnumber(L, 2, 32); int err = socket_listen(&tcp->sock, backlog); if (err != IO_DONE) { lua_pushnil(L); lua_pushstring(L, socket_strerror(err)); return 2; } /* turn master object into a server object */ auxiliar_setclass(L, "tcp{server}", 1); lua_pushnumber(L, 1); return 1; }
int main(){ lib_init(); socket_t * serverSocket = socket_new(); socket_bind(serverSocket, 5000); socket_listen(serverSocket); film_maker_t* film_makers[FILM_MAKERS_AMOUNT]; for (int i = 0; i < FILM_MAKERS_AMOUNT; i++) { film_makers[i] = film_maker_new(); } parse(film_makers,"XML_format.xml"); while(1) { socket_t * clientSocket = socket_accept(serverSocket); char buf[102400]; if(socket_read(clientSocket, buf, 102400) == 0) { socket_close(clientSocket); socket_free(clientSocket); puts("Skipping empty request"); continue; } http_request_t req = http_request_parse(buf); server_reply(clientSocket, req, film_makers); //puts("fghj"); socket_close(clientSocket); socket_free(clientSocket); } for (int i = 0; i < 3; i++) film_maker_free(film_makers[i]); socket_close(serverSocket); socket_free(serverSocket); lib_free(); return 0; }
static void ot_try_bind( char ip[4], uint16 port, int is_tcp ) { int64 s = is_tcp ? socket_tcp4( ) : socket_udp4(); if( socket_bind4_reuse( s, ip, port ) == -1 ) panic( "socket_bind4_reuse" ); if( is_tcp && ( socket_listen( s, SOMAXCONN) == -1 ) ) panic( "socket_listen" ); if( !io_fd( s ) ) panic( "io_fd" ); io_setcookie( s, is_tcp ? FLAG_TCP : FLAG_UDP ); io_wantread( s ); }
static int64_t ot_try_bind( ot_ip6 ip, uint16_t port ) { int64 sock = socket_tcp6( ); if( socket_bind6_reuse( sock, ip, port, 0 ) == -1 ) panic( "socket_bind6_reuse" ); if( socket_listen( sock, SOMAXCONN) == -1 ) panic( "socket_listen" ); if( !io_fd( sock ) ) panic( "io_fd" ); io_setcookie( sock, (void*)FLAG_SERVERSOCKET ); io_wantread( sock ); return sock; }
/** * @brief sctp_server_create * * @param sck [in] socket impl * @param ip [in] listen ip * @param port [in] listen port * * @return 0, if succ; -1, if failed */ int sctp_server_create(struct socket_impl *sck, const char *ip, unsigned short port) { struct sctp_initmsg initmsg = {0}; struct sctp_event_subscribe event = {0}; if (sck == NULL || sck->fd > 0) return -1; /* init impl */ memset(sck, 0, sizeof(*sck)); /* create, bind and listen socket */ if ((sck->fd = socket(PF_INET, SOCK_STREAM, IPPROTO_SCTP)) < 0) { perror("sctp socket failed"); } /* socket bind */ inet_addr_init(&sck->addr.in_addr, ip, port); socket_bind(sck->fd, (struct sockaddr *)&sck->addr.addr); /* init msg */ initmsg.sinit_num_ostreams = 5; initmsg.sinit_max_instreams = 5; initmsg.sinit_max_attempts = 4; if (setsockopt(sck->fd, IPPROTO_SCTP, SCTP_INITMSG, &initmsg, sizeof(initmsg)) < 0) perror("sctp setsockopt initmsg failed"); /* sctp event */ event.sctp_data_io_event = 1; if (setsockopt(sck->fd, IPPROTO_SCTP, SCTP_EVENTS, &event, sizeof(event)) < 0) perror("sctp setsockopt event failed"); /* socket listen */ socket_listen(sck->fd, 5); /* set socket block */ make_socket_block(sck->fd); /* create tcp server thread runtine */ if (pthread_create(&sck->ptd, NULL, tcp_server_backup_service, sck)) { printf("sctp server create failed.\n"); return -1; } return 0; }
void server_init (unsigned port) { unsigned sock; client_t client; _server_port = port; for (sock = 0; sock < MAX_SOCK_NUM; sock++) { client_init_sock (&client, sock); if (client_status (&client) == SnSR_CLOSED) { socket_init (sock, SnMR_TCP, port, 0); socket_listen (sock); _socket_port[sock] = port; break; } } }
/* test that a server responds correctly to attempted name refresh requests */ static bool nbt_refresh_own(struct torture_context *tctx) { struct nbt_name_refresh io; NTSTATUS status; struct nbt_name_socket *nbtsock = nbt_name_socket_init(tctx, NULL); const char *myaddress; struct socket_address *socket_address; struct nbt_name name; const char *address; if (!torture_nbt_get_name(tctx, &name, &address)) return false; myaddress = iface_best_ip(address); socket_address = socket_address_from_strings(tctx, nbtsock->sock->backend_name, myaddress, 0); torture_assert(tctx, socket_address != NULL, "Can't parse socket address"); status = socket_listen(nbtsock->sock, socket_address, 0, 0); torture_assert_ntstatus_ok(tctx, status, "socket_listen for nbt_referesh_own failed"); torture_comment(tctx, "Testing name defense to name refresh\n"); io.in.name = name; io.in.dest_addr = address; io.in.address = myaddress; io.in.nb_flags = NBT_NODE_B | NBT_NM_ACTIVE; io.in.broadcast = False; io.in.ttl = 1234; io.in.timeout = 3; io.in.retries = 0; status = nbt_name_refresh(nbtsock, tctx, &io); torture_assert_ntstatus_ok(tctx, status, talloc_asprintf(tctx, "Bad response from %s for name refresh", address)); CHECK_STRING(tctx, io.out.name.name, name.name); CHECK_VALUE(tctx, io.out.name.type, name.type); CHECK_VALUE(tctx, io.out.rcode, NBT_RCODE_ACT); return true; }
int nettest5(void) { int err; sockaddr addr; int new_fd; fd = socket_create(SOCK_PROTO_TCP, 0); printf("created socket, fd %d\n", fd); if(fd < 0) return 0; memset(&addr, 0, sizeof(addr)); addr.addr.len = 4; addr.addr.type = ADDR_TYPE_IP; addr.port = 1900; NETADDR_TO_IPV4(addr.addr) = IPV4_DOTADDR_TO_ADDR(0,0,0,0); err = socket_bind(fd, &addr); printf("socket_bind returns %d\n", err); if(err < 0) return 0; err = socket_listen(fd); printf("socket_listen returns %d\n", err); if(err < 0) return 0; new_fd = socket_accept(fd, &addr); printf("socket_accept returns %d\n", new_fd); if(new_fd < 0) return 0; err = socket_write(new_fd, "hello world!\n", strlen("hello world!\n")); printf("socket_write returns %d\n", err); printf("sleeping for 5 seconds\n"); usleep(5000000); printf("closing fd %d\n", new_fd); socket_close(new_fd); printf("closing fd %d\n", fd); socket_close(fd); return 0; }
void f_socket_listen (void) { int i, fd, port; char addr[ADDR_BUF_SIZE]; fd = (sp - 1)->u.number; get_socket_address(fd, addr, &port, 0); if (VALID_SOCKET("listen")) { i = socket_listen(fd, sp); pop_stack(); sp->u.number = i; } else { pop_stack(); sp->u.number = EESECURITY; } }
static void listen_thread(void* arg) { struct nr_mgr* mgr = (struct nr_mgr*)arg; sock client_fd = SOCKET_ERROR; struct sockaddr_in socketaddress; socklen_t size = sizeof(struct sockaddr); sock listen_fd = socket_listen(4002, 25); int total_num = 0; if(SOCKET_ERROR != listen_fd) { for(;;) { while((client_fd = accept(listen_fd, (struct sockaddr*)&socketaddress, &size)) < 0) { if(EINTR == sErrno) { continue; } } if(SOCKET_ERROR != client_fd) { total_num++; //printf("accept %d, current total num : %d\n", client_fd, total_num); nrmgr_addfd(mgr, client_fd); } } socket_close(listen_fd); listen_fd = SOCKET_ERROR; } else { //printf("listen failed\n"); } printf("exit\n"); exit(0); }
int main() { lib_init(); list_t* list=list_new(); lanser * freeLanser[10]; for (int i = 0; i < 10; i++) freeLanser[i] = Freelanser_new(); // parse(freeLanser); socket_t * serverSocket = socket_new(); socket_bind(serverSocket, 5000); socket_listen(serverSocket); while (1) { socket_t * clientSocket = socket_accept(serverSocket); char buf[10000]=""; if (!socket_read(clientSocket, buf, sizeof(buf))) { puts("Skipping empty request"); socket_close(clientSocket); socket_free(clientSocket); continue; } http_request_t req = http_request_parse(buf); server_answer(list,req,clientSocket,freeLanser); socket_close(clientSocket); socket_free(clientSocket); } socket_close(serverSocket); socket_free(serverSocket); lib_free(); list_free(list); return 0; }
/** * @brief start up a local server socket * * @param domain [in] This value can be AF_INET,AF_UNIX,AF_LOCAL, * PF_INET, PF_UINX and PF_LOCAL. * @param type [in] can be SOCK_TREAM, SOCK_DGRAM. * @param path [in] socket file path * @param is_ser [in] srever or client * * @return socket fd, if succ; exit, if fail */ int startup_local_server(int type, const char *path) { int fd = -1; struct sockaddr_un addr = {0}; /* init sockaddr_in */ local_addr_init(&addr, path); /* create socket */ fd = socket_create(AF_UNIX, type); make_listen_socket_reuseable(fd); unlink(addr.sun_path); /* bind and listen socket */ socket_bind(fd, (struct sockaddr *)&addr); if (type == SOCK_STREAM) socket_listen(fd, 5); return fd; }
static int init_socket(t_socket *sock, int port) { if (socket_ctor(sock, AF_INET, SOCK_STREAM, 0) == RET_FAILURE) { perror("error: socket creation"); return (RET_FAILURE); } if (socket_bind(sock, INADDR_ANY, port)) { perror("error: socket bind"); return (RET_FAILURE); } if (socket_listen(sock, 42) == RET_FAILURE) { perror("error: socket listen"); return (RET_FAILURE); } return (RET_SUCCESS); }
/** * Writes the received payload into payload argument and returns the tag of the message */ unsigned char server(unsigned char * payload) { ulong msg_len = PAYLOAD_LEN + 1; unsigned char* msg = malloc(msg_len); // receive the message BIO * b = socket_listen(); recv(b, msg, msg_len); // wait for the client to close, to avoid "Address already in use" errors wait_close(b); unsigned char * pad = otp(msg_len); // apply the one-time pad xor(msg, pad, msg_len); // get the payload memcpy(payload, msg + 1, PAYLOAD_LEN); // return the tag return *msg; }
static socket_t Listen(int port) { int r; socket_t server; server = socket_tcp(); if(socket_error == server) return socket_invalid; // reuse addr r = socket_setreuseaddr(server, 1); // bind r = socket_bind_any(server, (unsigned short)port); // listen r = socket_listen(server, 64); return server; }
int main() { lib_init(); socket_t * server = socket_new(); socket_bind(server, 5000); socket_listen(server); char buf[10000]; char pathBuf[256]; socket_t * client = NULL; while(1) { client = socket_accept(server); socket_read(client, buf, sizeof(buf)); if (strlen(buf) == 0) continue; printf(">> Got request:\n%s\n", buf); http_getPath(buf, pathBuf, sizeof(pathBuf)); http_request_t request = http_request_parse(buf); if (strcmp(request.uri, "/") == 0) { server_homepage(client); } else if (strcmp(request.uri, "/database") == 0) { server_students(client, &request); } else if (strcmp(request.uri, "/info") == 0) { server_info(client); } else if (strcmp(request.uri, "/filename") == 0) { server_file_parse(client); } else { server_notFound(client); } socket_free(client); } socket_free(server); lib_free(); return 0; }
/** * @brief start up a internet server socket * * @param domain [in] This value can be AF_INET,AF_UNIX,AF_LOCAL, * PF_INET, PF_UINX and PF_LOCAL. * @param type [in] can be SOCK_TREAM, SOCK_DGRAM. * @param ip [in] ip address, can be NULL * @param port [in] socket port * * @return socket fd, if succ; exit, if fail */ int startup_inet_server(int type, const char *ip, \ u_short port) { int fd = -1; struct sockaddr_in addr = {0}; /* create socket */ fd = socket_create(AF_INET, type); make_listen_socket_reuseable(fd); /* init sockaddr_in */ inet_addr_init(&addr, ip, port); /* bind socket */ socket_bind(fd, (struct sockaddr *)&addr); /* build socket listen */ if (type == SOCK_STREAM) socket_listen(fd, 5); return fd; }
int qio_channel_socket_listen_sync(QIOChannelSocket *ioc, SocketAddress *addr, Error **errp) { int fd; trace_qio_channel_socket_listen_sync(ioc, addr); fd = socket_listen(addr, errp); if (fd < 0) { trace_qio_channel_socket_listen_fail(ioc); return -1; } trace_qio_channel_socket_listen_complete(ioc, fd); if (qio_channel_socket_set_fd(ioc, fd, errp) < 0) { close(fd); return -1; } return 0; }
void StartServer(){ int sockstat, listsock; listsock = socket_create(STREAM,"read_callback","close_callback"); if(listsock < 0){ debug("Couldn't create socket. errorcode: "+listsock); return; } sockstat = socket_bind(listsock,port); if(sockstat < 0){ debug("Couldn't bind socket. errorcode: "+sockstat); return; } sockstat = socket_listen(listsock,"listen_callback"); if(sockstat < 0){ debug("Couldn't listen on socket. errorcode: "+sockstat); return; } }
int Dps_ftp_open_data_port( DPS_CONN *c, DPS_CONN *d){ char buf[64]; unsigned char *a, *p; int code; if (!d) return -1; if (socket_getname(c, &d->sin) == -1) return -1; if (d->port) { d->sin.sin_port = htons(d->port); } if (socket_open(d)) return -1; if (socket_listen(d)){ return -1; } if (socket_getname(d, &d->sin) == -1){ return -1; } a = (unsigned char *)&d->sin.sin_addr; p = (unsigned char *)&d->sin.sin_port; dps_snprintf(buf, 64, "PORT %d,%d,%d,%d,%d,%d", a[0], a[1], a[2], a[3], p[0], p[1]); code = Dps_ftp_send_cmd(c, buf); if ((code < 0) || strncasecmp(c->buf, "200 ", 4)){ return -1; } d->user = c->user; d->pass = c->pass; return 0; }
void http_request_startServer(pupils_t pupils){ lib_init(); socket_t * serverSocket = socket_new(); socket_bind(serverSocket, 5000); socket_listen(serverSocket); while(1){ puts("Waiting for connections"); socket_t * clientSocket = socket_accept(serverSocket); puts("New client"); char buff[BUFFER_LENGTH]; int readLength = socket_read(clientSocket, buff, BUFFER_LENGTH); if(readLength == 0){ socket_close(clientSocket); socket_free(clientSocket); puts("Skipping empty request"); continue; } printf("Got Request:\n---------------\n%s\n----------------\n", buff); http_request_t req = http_request_parse(buff); printf("Method: %s\nURI: %s\n", req.method, req.uri); puts("Data:"); for(int i = 0; i < req.formLength; i++){ char * kvStr = keyvalue_toString(&req.form[i]); printf("\t%s\n", kvStr); free(kvStr); } http_request_chooseMethod(req, clientSocket, pupils); socket_close(clientSocket); socket_free(clientSocket); } socket_close(serverSocket); socket_free(serverSocket); lib_free(); }
int main() { lib_init(); socket_t * server = socket_new(); socket_bind(server, 5000); socket_listen(server); char buf[10000]; char pathBuf[256]; socket_t * client = NULL; while(1) { client = socket_accept(server); socket_read(client, buf, sizeof(buf)); http_request_t rs; rs = http_request_parse(buf); server_reply(client,rs); } socket_free(server); socket_free(client); lib_free(); return 0; }
int main() { lib_init(); socket_t * server = socket_new(); socket_bind(server, 5000); socket_listen(server); char buf[10000]; char pathBuf[256]; socket_t * client = NULL; while(1) { client = socket_accept(server); socket_read(client, buf, sizeof(buf)); if (strlen(buf) == 0) continue; printf(">> Got request:\n%s\n", buf); http_getPath(buf, pathBuf, sizeof(pathBuf)); http_request_t request = http_request_parse(buf); if (strcmp(request.uri, "/") == 0) { server_homepage(client); } else if (strcmp(request.uri, "/api/admins") == 0) { server_database(client); } else if (strcmp(request.uri, "/api/admins/") > 0) { server_database_id(client, &request); } else { error_massage(client, "404 - NOT FOUND!"); } socket_free(client); } socket_free(server); lib_free(); return 0; }
static int start_web_server(http_conf *g) { int count ; int epfd; int fd = 0; epoll_extra_data_t *data; data = (epoll_extra_data_t *) malloc(sizeof(epoll_extra_data_t)); data->type = SERVERFD; if(g->port <=0) g->port = 80; epfd = epoll_init(MAX_CONNECT); //while(count--){ fd = socket_listen("127.0.0.1", g->port); // web->fd = fd; epoll_add_fd(epfd, fd,EPOLL_R, data); // web = web->next; //} g->fd = fd; g->epfd = epfd; return epfd; }
int main() { db_t* base = db_new("workers.db"); lib_init(); socket_t* server = socket_new(); socket_bind(server, PORT); socket_listen(server); char buffer[10000]; while(true) { puts("Waiting for client...!"); socket_t* client = socket_accept(server); if(socket_read(client, buffer, sizeof(buffer)) <= 0) { socket_close(client); socket_free(client); continue; } printf("Request:\n%s\n", buffer); http_request_t request = http_request_parse(buffer); server_answerRequest(request, client, base); socket_free(client); } socket_free(server); lib_free(); db_free(base); return 0; }
int mesh_start_listening(Socket *mesh_listen_socket, uint16_t mesh_listen_socket_port, SocketCreateAllocatedFunction create_allocated) { int phase = 0; struct addrinfo *resolved_address = NULL; const char *address = config_get_option_value("listen.address")->string; log_info("Opening mesh listen socket (P: %u)", mesh_listen_socket_port); resolved_address = socket_hostname_to_address(address, mesh_listen_socket_port); // Currently no IPv6 support for mesh. if(resolved_address->ai_family == AF_INET6) { log_error("Mesh gateway does not support IPv6"); goto CLEANUP; } if (resolved_address == NULL) { log_error("Could not resolve mesh listen address '%s' (P: %u): %s (%d)", address, mesh_listen_socket_port, get_errno_name(errno), errno); goto CLEANUP; } phase = 1; // Create socket. if (socket_create(mesh_listen_socket) < 0) { log_error("Could not create mesh listen socket: %s (%d)", get_errno_name(errno), errno); goto CLEANUP; } phase = 2; if (socket_open(mesh_listen_socket, resolved_address->ai_family, resolved_address->ai_socktype, resolved_address->ai_protocol) < 0) { log_error("Could not open %s mesh listen socket: %s (%d)", network_get_address_family_name(resolved_address->ai_family, false), get_errno_name(errno), errno); goto CLEANUP; } #ifndef _WIN32 /* * On Unix the SO_REUSEADDR socket option allows to rebind sockets in * CLOSE-WAIT state. this is a desired effect. On Windows SO_REUSEADDR * allows to rebind sockets in any state. This is dangerous. Therefore, * don't set SO_REUSEADDR on Windows. Sockets can be rebound in CLOSE-WAIT * state on Windows by default. */ if (socket_set_address_reuse(mesh_listen_socket, true) < 0) { log_error("Could not enable address-reuse mode for mesh listen socket: %s (%d)", get_errno_name(errno), errno); goto CLEANUP; } #endif // Bind socket and start to listen. if (socket_bind(mesh_listen_socket, resolved_address->ai_addr, resolved_address->ai_addrlen) < 0) { log_error("Could not bind %s mesh listen socket to (A: %s, P: %u): %s (%d)", network_get_address_family_name(resolved_address->ai_family, true), address, mesh_listen_socket_port, get_errno_name(errno), errno); goto CLEANUP; } if (socket_listen(mesh_listen_socket, 10, create_allocated) < 0) { log_error("Could not listen to %s mesh socket (A: %s, P: %u): %s (%d)", network_get_address_family_name(resolved_address->ai_family, true), address, mesh_listen_socket_port, get_errno_name(errno), errno); goto CLEANUP; } log_info("Mesh gateway started listening on (A: %s, P: %u, F: %s)", address, mesh_listen_socket_port, network_get_address_family_name(resolved_address->ai_family, true)); if(event_add_source(mesh_listen_socket->base.handle, EVENT_SOURCE_TYPE_GENERIC, EVENT_READ, mesh_handle_accept, mesh_listen_socket) < 0) { goto CLEANUP; } phase = 3; freeaddrinfo(resolved_address); CLEANUP: switch(phase) { // No breaks, all cases fall through intentionally. case 2: socket_destroy(mesh_listen_socket); case 1: freeaddrinfo(resolved_address); default: break; } return phase == 3 ? 0 : -1; }
/* test UDP/138 netlogon requests */ static bool nbt_test_netlogon(struct torture_context *tctx) { struct dgram_mailslot_handler *dgmslot; struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(tctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx)); struct socket_address *dest; const char *myaddress; struct nbt_netlogon_packet logon; struct nbt_netlogon_response *response; struct nbt_name myname; NTSTATUS status; struct timeval tv = timeval_current(); struct socket_address *socket_address; const char *address; struct nbt_name name; struct interface *ifaces; name.name = lp_workgroup(tctx->lp_ctx); name.type = NBT_NAME_LOGON; name.scope = NULL; /* do an initial name resolution to find its IP */ torture_assert_ntstatus_ok(tctx, resolve_name(lp_resolve_context(tctx->lp_ctx), &name, tctx, &address, tctx->ev), talloc_asprintf(tctx, "Failed to resolve %s", name.name)); load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces); myaddress = talloc_strdup(dgmsock, iface_best_ip(ifaces, address)); socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name, myaddress, lp_dgram_port(tctx->lp_ctx)); torture_assert(tctx, socket_address != NULL, "Error getting address"); /* try receiving replies on port 138 first, which will only work if we are root and smbd/nmbd are not running - fall back to listening on any port, which means replies from most windows versions won't be seen */ status = socket_listen(dgmsock->sock, socket_address, 0, 0); if (!NT_STATUS_IS_OK(status)) { talloc_free(socket_address); socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name, myaddress, 0); torture_assert(tctx, socket_address != NULL, "Error getting address"); socket_listen(dgmsock->sock, socket_address, 0, 0); } /* setup a temporary mailslot listener for replies */ dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC, netlogon_handler, NULL); ZERO_STRUCT(logon); logon.command = LOGON_PRIMARY_QUERY; logon.req.pdc.computer_name = TEST_NAME; logon.req.pdc.mailslot_name = dgmslot->mailslot_name; logon.req.pdc.unicode_name = TEST_NAME; logon.req.pdc.nt_version = 1; logon.req.pdc.lmnt_token = 0xFFFF; logon.req.pdc.lm20_token = 0xFFFF; make_nbt_name_client(&myname, TEST_NAME); dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name, address, lp_dgram_port(tctx->lp_ctx)); torture_assert(tctx, dest != NULL, "Error getting address"); status = dgram_mailslot_netlogon_send(dgmsock, &name, dest, NBT_MAILSLOT_NETLOGON, &myname, &logon); torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request"); while (timeval_elapsed(&tv) < 5 && !dgmslot->private_data) { event_loop_once(dgmsock->event_ctx); } response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response); torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet"); torture_assert(tctx, response->response_type == NETLOGON_GET_PDC, "Got incorrect type of netlogon response"); torture_assert(tctx, response->data.get_pdc.command == NETLOGON_RESPONSE_FROM_PDC, "Got incorrect netlogon response command"); return true; }
/* test UDP/138 netlogon requests */ static bool nbt_test_netlogon2(struct torture_context *tctx) { struct dgram_mailslot_handler *dgmslot; struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(tctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx)); struct socket_address *dest; const char *myaddress; struct nbt_netlogon_packet logon; struct nbt_netlogon_response *response; struct nbt_name myname; NTSTATUS status; struct timeval tv = timeval_current(); struct socket_address *socket_address; const char *address; struct nbt_name name; struct interface *ifaces; struct test_join *join_ctx; struct cli_credentials *machine_credentials; const struct dom_sid *dom_sid; name.name = lp_workgroup(tctx->lp_ctx); name.type = NBT_NAME_LOGON; name.scope = NULL; /* do an initial name resolution to find its IP */ torture_assert_ntstatus_ok(tctx, resolve_name(lp_resolve_context(tctx->lp_ctx), &name, tctx, &address, tctx->ev), talloc_asprintf(tctx, "Failed to resolve %s", name.name)); load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces); myaddress = talloc_strdup(dgmsock, iface_best_ip(ifaces, address)); socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name, myaddress, lp_dgram_port(tctx->lp_ctx)); torture_assert(tctx, socket_address != NULL, "Error getting address"); /* try receiving replies on port 138 first, which will only work if we are root and smbd/nmbd are not running - fall back to listening on any port, which means replies from some windows versions won't be seen */ status = socket_listen(dgmsock->sock, socket_address, 0, 0); if (!NT_STATUS_IS_OK(status)) { talloc_free(socket_address); socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name, myaddress, 0); torture_assert(tctx, socket_address != NULL, "Error getting address"); socket_listen(dgmsock->sock, socket_address, 0, 0); } /* setup a temporary mailslot listener for replies */ dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC, netlogon_handler, NULL); ZERO_STRUCT(logon); logon.command = LOGON_SAM_LOGON_REQUEST; logon.req.logon.request_count = 0; logon.req.logon.computer_name = TEST_NAME; logon.req.logon.user_name = ""; logon.req.logon.mailslot_name = dgmslot->mailslot_name; logon.req.logon.nt_version = NETLOGON_NT_VERSION_5EX_WITH_IP|NETLOGON_NT_VERSION_5|NETLOGON_NT_VERSION_1; logon.req.logon.lmnt_token = 0xFFFF; logon.req.logon.lm20_token = 0xFFFF; make_nbt_name_client(&myname, TEST_NAME); dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name, address, lp_dgram_port(tctx->lp_ctx)); torture_assert(tctx, dest != NULL, "Error getting address"); status = dgram_mailslot_netlogon_send(dgmsock, &name, dest, NBT_MAILSLOT_NETLOGON, &myname, &logon); torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request"); while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) { event_loop_once(dgmsock->event_ctx); } response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response); torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet"); torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response"); map_netlogon_samlogon_response(&response->data.samlogon); torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX, "Got incorrect netlogon response command"); torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.nt_version, NETLOGON_NT_VERSION_5EX_WITH_IP|NETLOGON_NT_VERSION_5EX|NETLOGON_NT_VERSION_1, "Got incorrect netlogon response command"); /* setup (another) temporary mailslot listener for replies */ dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC, netlogon_handler, NULL); ZERO_STRUCT(logon); logon.command = LOGON_SAM_LOGON_REQUEST; logon.req.logon.request_count = 0; logon.req.logon.computer_name = TEST_NAME; logon.req.logon.user_name = TEST_NAME"$"; logon.req.logon.mailslot_name = dgmslot->mailslot_name; logon.req.logon.nt_version = 1; logon.req.logon.lmnt_token = 0xFFFF; logon.req.logon.lm20_token = 0xFFFF; make_nbt_name_client(&myname, TEST_NAME); dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name, address, lp_dgram_port(tctx->lp_ctx)); torture_assert(tctx, dest != NULL, "Error getting address"); status = dgram_mailslot_netlogon_send(dgmsock, &name, dest, NBT_MAILSLOT_NETLOGON, &myname, &logon); torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request"); while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) { event_loop_once(dgmsock->event_ctx); } response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response); torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet"); torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response"); map_netlogon_samlogon_response(&response->data.samlogon); torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN, "Got incorrect netlogon response command"); torture_assert_str_equal(tctx, response->data.samlogon.data.nt5_ex.user_name, TEST_NAME"$", "Got incorrect user in netlogon response"); join_ctx = torture_join_domain(tctx, TEST_NAME, ACB_WSTRUST, &machine_credentials); torture_assert(tctx, join_ctx != NULL, talloc_asprintf(tctx, "Failed to join domain %s as %s\n", lp_workgroup(tctx->lp_ctx), TEST_NAME)); dom_sid = torture_join_sid(join_ctx); /* setup (another) temporary mailslot listener for replies */ dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC, netlogon_handler, NULL); ZERO_STRUCT(logon); logon.command = LOGON_SAM_LOGON_REQUEST; logon.req.logon.request_count = 0; logon.req.logon.computer_name = TEST_NAME; logon.req.logon.user_name = TEST_NAME"$"; logon.req.logon.mailslot_name = dgmslot->mailslot_name; logon.req.logon.sid = *dom_sid; logon.req.logon.nt_version = 1; logon.req.logon.lmnt_token = 0xFFFF; logon.req.logon.lm20_token = 0xFFFF; make_nbt_name_client(&myname, TEST_NAME); dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name, address, lp_dgram_port(tctx->lp_ctx)); torture_assert(tctx, dest != NULL, "Error getting address"); status = dgram_mailslot_netlogon_send(dgmsock, &name, dest, NBT_MAILSLOT_NETLOGON, &myname, &logon); torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request"); while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) { event_loop_once(dgmsock->event_ctx); } response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response); torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet"); torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response"); map_netlogon_samlogon_response(&response->data.samlogon); torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN, "Got incorrect netlogon response command"); /* setup (another) temporary mailslot listener for replies */ dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC, netlogon_handler, NULL); torture_assert(tctx, dgmslot != NULL, "Error getting a Mailslot for GetDC reply"); ZERO_STRUCT(logon); logon.command = LOGON_SAM_LOGON_REQUEST; logon.req.logon.request_count = 0; logon.req.logon.computer_name = TEST_NAME; logon.req.logon.user_name = TEST_NAME"$"; logon.req.logon.mailslot_name = dgmslot->mailslot_name; logon.req.logon.sid = *dom_sid; logon.req.logon.acct_control = ACB_WSTRUST; logon.req.logon.nt_version = 1; logon.req.logon.lmnt_token = 0xFFFF; logon.req.logon.lm20_token = 0xFFFF; make_nbt_name_client(&myname, TEST_NAME); dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name, address, lp_dgram_port(tctx->lp_ctx)); torture_assert(tctx, dest != NULL, "Error getting address"); status = dgram_mailslot_netlogon_send(dgmsock, &name, dest, NBT_MAILSLOT_NETLOGON, &myname, &logon); torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request"); while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) { event_loop_once(dgmsock->event_ctx); } response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response); torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet"); torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response"); map_netlogon_samlogon_response(&response->data.samlogon); torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE, "Got incorrect netlogon response command"); dgmslot->private_data = NULL; ZERO_STRUCT(logon); logon.command = LOGON_SAM_LOGON_REQUEST; logon.req.logon.request_count = 0; logon.req.logon.computer_name = TEST_NAME; logon.req.logon.user_name = TEST_NAME"$"; logon.req.logon.mailslot_name = dgmslot->mailslot_name; logon.req.logon.sid = *dom_sid; logon.req.logon.acct_control = ACB_NORMAL; logon.req.logon.nt_version = 1; logon.req.logon.lmnt_token = 0xFFFF; logon.req.logon.lm20_token = 0xFFFF; make_nbt_name_client(&myname, TEST_NAME); dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name, address, lp_dgram_port(tctx->lp_ctx)); torture_assert(tctx, dest != NULL, "Error getting address"); status = dgram_mailslot_netlogon_send(dgmsock, &name, dest, NBT_MAILSLOT_NETLOGON, &myname, &logon); torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request"); while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) { event_loop_once(dgmsock->event_ctx); } response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response); torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet"); torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response"); map_netlogon_samlogon_response(&response->data.samlogon); torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN, "Got incorrect netlogon response command"); torture_leave_domain(tctx, join_ctx); return true; }
int main(int argc, char *argv[]) { struct addrinfo hints; int ch, ls[FD_SETSIZE], nls, as, cs, optval; const char *listenaddr, *listenport, *hostname, *port; const char *relayname; void (*relayfunc)(int, int); relayname = strrchr(argv[0], '/'); relayname = relayname ? relayname + 1 : argv[0]; if (strcmp(relayname, "copy") == 0) relayfunc = relay_copy; else if (strcmp(relayname, "splice") == 0) relayfunc = relay_splice; else { argc--; argv++; if (argv[0] == NULL) usage(); relayname = argv[0]; if (strcmp(relayname, "copy") == 0) relayfunc = relay_copy; else if (strcmp(relayname, "splice") == 0) relayfunc = relay_splice; else usage(); } memset(&hints, 0, sizeof(hints)); hints.ai_family = PF_UNSPEC; hints.ai_socktype = SOCK_STREAM; listenaddr = NULL; while ((ch = getopt(argc, argv, "46b:tu")) != -1) { switch (ch) { case '4': hints.ai_family = PF_INET; break; case '6': hints.ai_family = PF_INET6; break; case 'b': listenaddr = optarg; break; case 't': hints.ai_socktype = SOCK_STREAM; break; case 'u': hints.ai_socktype = SOCK_DGRAM; break; default: usage(); } } argc -= optind; argv += optind; if (argc != 3) usage(); listenport = argv[0]; hostname = argv[1]; port = argv[2]; nls = socket_listen(ls, &hints, listenaddr, listenport); while (1) { if (hints.ai_socktype == SOCK_STREAM) { as = socket_accept(listen_select(ls, nls)); cs = socket_connect(&hints, hostname, port); optval = 1; if (setsockopt(cs, IPPROTO_TCP, TCP_NODELAY, &optval, sizeof(optval)) == -1) err(1, "setsockopt nodelay"); } else { cs = socket_connect(&hints, hostname, port); as = listen_select(ls, nls); } relayfunc(as, cs); if (close(cs) == -1) err(1, "connect close"); if (hints.ai_socktype == SOCK_STREAM) { if (close(as) == -1) err(1, "accept close"); } printf("close\n"); } }