/* wrapper function for auth thread to authenticate new listener * connection details */ static void auth_new_listener (auth_client *auth_user) { client_t *client = auth_user->client; /* make sure there is still a client at this point, a slow backend request * can be avoided if client has disconnected */ if (allow_auth == 0 || client_connected (client) == 0) { DEBUG0 ("dropping listener connection"); client->respcode = 400; return; } if (auth_user->auth->authenticate) { switch (auth_user->auth->authenticate (auth_user)) { case AUTH_OK: case AUTH_FAILED: break; default: return; } } auth_postprocess_listener (auth_user); }
void client_outmessage (enum outmsg_type msgtype, char *str) { char buf[1024]; GTET_O_STRCPY(buf, outmsg_translate (msgtype)); if (str) { GTET_O_STRCAT(buf, " "); GTET_O_STRCAT(buf, str); } switch (msgtype) { case OUT_DISCONNECT : client_disconnect (); break; case OUT_CONNECTED : client_connected (); break; default : client_sendmsg (buf); } }
/** @brief Read and process available transport_messages for a transport_client. @param client Pointer to the transport_client whose socket is to be read. @param timeout How many seconds to wait for the first message. @param msg_received A pointer through which to report whether a message was received. @return 0 upon success (even if a timeout occurs), or -1 upon failure. Read and process all available transport_messages from the socket of the specified transport_client. Pass each one through osrf_stack_transport(). The timeout applies only to the first message. Any subsequent messages must be available immediately. Don't wait for them, even if the timeout has not expired. In theory, a sufficiently large backlog of input messages could keep you working past the nominal expiration of the timeout. The @a msg_received parameter points to an int owned by the calling code and used as a boolean. Set it to true if you receive at least one transport_message, or to false if you don't. A timeout is not treated as an error; it just means you must set that boolean to false. */ int osrf_stack_process( transport_client* client, int timeout, int* msg_received ) { if( !client ) return -1; transport_message* msg = NULL; if(msg_received) *msg_received = 0; // Loop through the available input messages while( (msg = client_recv( client, timeout )) ) { if(msg_received) *msg_received = 1; osrfLogDebug( OSRF_LOG_MARK, "Received message from transport code from %s", msg->sender ); osrf_stack_transport_handler( msg, NULL ); timeout = 0; } if( client->error ) { osrfLogWarning(OSRF_LOG_MARK, "transport_client had trouble reading from the socket.."); return -1; } if( ! client_connected( client ) ) return -1; return 0; }
void Server::check_for_new_connections() { if (m_state != STARTED) { printf("Trying to call check_new_connections() while the server isn't ready. STATE was %d\n", m_state); return; } SOCKET client_socket; client_socket = INVALID_SOCKET; // Accept a client socket client_socket = accept(m_listen_socket, NULL, NULL); if (client_socket == INVALID_SOCKET) { int error_code = WSAGetLastError(); if (error_code == WSAEWOULDBLOCK) { return; } else { printf("accept failed: %d\n", error_code); m_state = IN_ERROR_STATE; return; } } else { client_connected(client_socket); } }
void client_destroy(client_t *client) { if (client == NULL) return; if (client->worker) { WARN0 ("client still on worker thread"); return; } /* release the buffer now, as the buffer could be on the source queue * and may of disappeared after auth completes */ if (client->refbuf) { refbuf_release (client->refbuf); client->refbuf = NULL; } if (client->flags & CLIENT_AUTHENTICATED) DEBUG1 ("client still in auth \"%s\"", httpp_getvar (client->parser, HTTPP_VAR_URI)); /* write log entry if ip is set (some things don't set it, like outgoing * slave requests */ if (client->respcode > 0 && client->parser) logging_access(client); if (client->flags & CLIENT_IP_BAN_LIFT) { INFO1 ("lifting IP ban on client at %s", client->connection.ip); connection_release_banned_ip (client->connection.ip); client->flags &= ~CLIENT_IP_BAN_LIFT; } if (client->parser) httpp_destroy (client->parser); /* we need to free client specific format data (if any) */ if (client->free_client_data) client->free_client_data (client); free(client->username); free(client->password); client->username = NULL; client->password = NULL; client->parser = NULL; client->respcode = 0; client->free_client_data = NULL; global_lock (); if (global.running != ICE_RUNNING || client->connection.error || (client->flags & CLIENT_KEEPALIVE) == 0 || client_connected (client) == 0) { global.clients--; stats_event_args (NULL, "clients", "%d", global.clients); config_clear_listener (client->server_conn); global_unlock (); connection_close (&client->connection); free(client); return; } global_unlock (); DEBUG0 ("keepalive detected, placing back onto worker"); client->counter = client->schedule_ms = timing_get_time(); client->connection.con_time = client->schedule_ms/1000; client->connection.discon.time = client->connection.con_time + 7; client->ops = &http_request_ops; client->flags = CLIENT_ACTIVE; client->shared_data = NULL; client->refbuf = NULL; client->pos = 0; client->intro_offset = client->connection.sent_bytes = 0; client_add_worker (client); }