int main(void) {
// initializing first three investors for program to start with
// initializing_END
int PORT = 5000;
lib_init();
winSock = socket_new();
db_t * db = db_new("teacher.db");
// Checking if socket is not busy, closing app if it is
if (socket_bind(winSock, PORT) == SOCKET_ERROR) {
printf("Cannot bind %i port\n", PORT);
socket_close(winSock);
socket_free(winSock);
return 0;
}
socket_listen(winSock);
char buf[10000];
socket_t * client = NULL;
// main cycle of the program
while (1) {
printf("Awaiting for connections...\n");
client = socket_accept(winSock);
// Checking if client is not null, closing app if he is
if (client == NULL) {
printf("NULL client, closing app...\n");
break;
}
int readStatus = socket_read(client, buf, sizeof(buf));
// Skipping empty request (may appear from time to time)
if (readStatus <= 0) {
printf("Empty request, skipping...\n");
socket_close(client);
socket_free(client);
continue;
}
// Printing info about the received request to console
printf(">> Got request (readStatus: %i):\n'%s'\n", readStatus, buf);
http_request_t request = http_request_parse(buf);
// check the type/path of request (API/HTML) & analyze the method (GET/POST/DELETE)
// and provide the client with proper answer
server_analyzeRequest(&request, client, db);
socket_free(client);
}
// end of program
socket_close(winSock);
socket_free(winSock);
db_free(db);
lib_free();
return 0;
}
int
main(int argc, const char *argv[])
{
Socket* serverSock, *controlSock;
int c;
poptContext optCon = poptGetContext(NULL, argc, argv, options, 0);
poptSetOtherOptionHelp(optCon, "configFile");
while ((c = poptGetNextOpt(optCon)) >= 0) {
switch (c) {
case 'v':
printf(V_STRING, VERSION);
printf(COPYRIGHT);
return 0;
}
}
setup_logging (logfile_name, log_level);
if (c < -1) {
/* an error occurred during option processing */
fprintf(stderr, "%s: %s\n",
poptBadOption(optCon, POPT_BADOPTION_NOALIAS),
poptStrerror(c));
return -1;
}
loginfo (V_STRING, VERSION);
loginfo (COPYRIGHT);
struct sigaction new_action, old_action;
new_action.sa_handler = sigpipe_handler;
sigemptyset (&new_action.sa_mask);
new_action.sa_flags = 0;
sigaction (SIGPIPE, NULL, &old_action);
if (old_action.sa_handler != SIG_IGN)
sigaction (SIGPIPE, &new_action, NULL);
prepare_stdin(NULL);
eventloop_init();
session = (Session*) malloc(sizeof(Session));
memset(session, 0, sizeof(Session));
session->state = ProxyState_PAUSED;
serverSock = socket_server_new("proxy_server", listen_port, on_connect, NULL);
controlSock = socket_server_new("proxy_server_control", listen_port + 1, on_control_connect, NULL);
eventloop_on_stdin(stdin_handler, session);
eventloop_run();
socket_free(serverSock);
socket_free(controlSock);
return(0);
}
status_t
socket_socketpair(int family, int type, int protocol, net_socket* sockets[2])
{
sockets[0] = NULL;
sockets[1] = NULL;
// create sockets
status_t error = socket_open(family, type, protocol, &sockets[0]);
if (error != B_OK)
return error;
if (error == B_OK)
error = socket_open(family, type, protocol, &sockets[1]);
// bind one
if (error == B_OK)
error = socket_bind(sockets[0], NULL, 0);
// start listening
if (error == B_OK)
error = socket_listen(sockets[0], 1);
// connect them
if (error == B_OK) {
error = socket_connect(sockets[1], (sockaddr*)&sockets[0]->address,
sockets[0]->address.ss_len);
}
// accept a socket
net_socket* acceptedSocket = NULL;
if (error == B_OK)
error = socket_accept(sockets[0], NULL, NULL, &acceptedSocket);
if (error == B_OK) {
// everything worked: close the listener socket
socket_close(sockets[0]);
socket_free(sockets[0]);
sockets[0] = acceptedSocket;
} else {
// close sockets on error
for (int i = 0; i < 2; i++) {
if (sockets[i] != NULL) {
socket_close(sockets[i]);
socket_free(sockets[i]);
sockets[i] = NULL;
}
}
}
return error;
}
Socket*
socket_mc_out_new(
char* name, //! Name used for debugging
char* mcast_addr, //! IP address of the multicast socket/channel.
int mcast_port, //! Port used
char* iface //! Name of the interface (eth0/eth1) to bind to
) {
SocketInt* self;
// if ((self = (SocketInt*)socket_new(name, mcast_addr, 0)) == NULL)
// return NULL;
if ((self = (SocketInt*)socket_new(name, FALSE)) == NULL)
return NULL;
// Multicast parameters
unsigned char ttl = 3;
unsigned char one = 3; // loopback
struct in_addr addr;
addr.s_addr = iface2addr(name, iface);
o_log(O_LOG_DEBUG, "socket:%s: Binding to %x\n", name, addr.s_addr);
if (setsockopt(self->sockfd, IPPROTO_IP, IP_MULTICAST_IF, &addr, sizeof(addr)) < 0) {
o_log (O_LOG_ERROR, "socket:%s: Setting outgoing interface for socket\n\t%s",
name, strerror(errno));
socket_free((Socket*)socket);
return NULL;
}
if (setsockopt(self->sockfd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl,
sizeof(unsigned char)) < 0) {
o_log(O_LOG_ERROR, "socket:%s: While setting TTL parameter for multicast socket\n\t%s",
name, strerror(errno));
socket_free((Socket*)socket);
return NULL;
}
if (setsockopt(self->sockfd, IPPROTO_IP, IP_MULTICAST_LOOP,
&one, sizeof(unsigned char)) < 0) {
o_log(O_LOG_ERROR, "socket%s: While setting the loopback on multicast socket\n\t%s",
name, strerror(errno));
socket_free((Socket*)socket);
return NULL;
}
// self->addr = mcast_addr;
self->servAddr.sin_port = htons(mcast_port);
self->servAddr.sin_addr.s_addr = inet_addr(mcast_addr);
o_log(O_LOG_DEBUG, "socket:%s: Ready to send data on: %s:%d\n",
name, mcast_addr, mcast_port);
return (Socket*)self;
}
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;
}
/** Create an IP Socket object bound to ADDR and PORT.
*
* This function binds the newly-created socket, but doesn't listen on it just yet.
*
* \param name name of the object, used for debugging
* \param port port used
* \param is_tcp true if TCP, false for UDP XXX: This should be more generic
* \return a pointer to the SocketInt object, cast as a Socket
*/
Socket* socket_in_new(
char* name,
int port,
int is_tcp
) {
SocketInt* self;
if ((self = (SocketInt*)socket_new(name, is_tcp)) == NULL)
return NULL;
// o_log(O_LOG_DEBUG, "socket:%s: Attempt to join %s:%d\n", name, addr, port);
self->servAddr.sin_family = PF_INET;
self->servAddr.sin_port = htons(port);
self->servAddr.sin_addr.s_addr = htonl(INADDR_ANY);
if(bind(self->sockfd, (struct sockaddr *)&self->servAddr,
sizeof(struct sockaddr_in)) < 0) {
o_log(O_LOG_ERROR, "socket:%s: Error binding socket to interface: %s\n",
name, strerror(errno));
socket_free((Socket*)self);
return NULL;
}
self->localport = ntohs(self->servAddr.sin_port);
o_log(O_LOG_DEBUG, "socket:%s: Socket bound to port: %d\n", name, self->localport);
self->next = instances;
instances = self;
return (Socket*)self;
}
/* Close all sockets, free all the socket structs, and send a RST
* packet to clean up kernel state for each connection.
* TODO(ncardwell): centralize error handling and ensure test errors
* always result in a call to these clean-up functions, so we can make
* sure to reset connections in all cases.
*/
static void close_all_sockets(struct state *state)
{
struct socket *socket = state->sockets;
while (socket != NULL) {
if (socket->live.fd >= 0 && !socket->is_closed) {
assert(socket->script.fd >= 0);
DEBUGP("closing struct state socket "
"live.fd:%d script.fd:%d\n",
socket->live.fd, socket->script.fd);
if (close(socket->live.fd))
die_perror("close");
}
if ((socket->state != SOCKET_INIT) &&
(socket->state != SOCKET_NEW) &&
(socket->state != SOCKET_PASSIVE_LISTENING) &&
(state->config->is_wire_client == false)) {
switch (socket->protocol) {
case IPPROTO_TCP:
if (reset_connection(state, socket) != STATUS_OK)
die("error reseting connection\n");
break;
case IPPROTO_SCTP:
if (abort_association(state, socket) != STATUS_OK)
die("error aborting association\n");
break;
default:
break;
}
}
struct socket *dead_socket = socket;
socket = socket->next;
socket_free(dead_socket);
}
}
tcp_result cph_tcp_suspend(socket_connection_t *cnx)
{
// TODO: SEMAPHORE TAKE GIVE TASK NOTIFY
tcp_result result;
comm_request_t request;
request.type = REQUEST_SUSPEND;
if(xQueueSendToBack( xCommQueueRequest, &request, (TickType_t)0) == pdTRUE) {
while(true) {
if(cnx->socket->socket_error > 0) {
result = SYS_ERR_TCP_FAIL;
break;
}
if(cnx->socket->socket_status == SCK_SUSPENDED) {
result = SYS_TCP_OK;
break;
}
}
}
if(xSemaphoreTake(tcp_suspend_signal, portMAX_DELAY)) {
//printf("tcp_connect: connected.\r\n");
}
socket_free();
return result;
}
void
client_free (Client *client)
{
if (client == NULL) return;
if (client->file) {
fflush (client->file);
fclose (client->file);
client->file = NULL;
}
oml_free (client->file_name);
oml_free (client->downstream_addr);
struct header *header = client->headers;
while (header) {
struct header *next = header->next;
header_free (header);
header = next;
}
msg_queue_destroy (client->messages);
cbuf_destroy (client->cbuf);
pthread_cond_destroy (&client->condvar);
pthread_mutex_destroy (&client->mutex);
socket_free (client->recv_socket);
oml_free (client);
}
/**
* Test the connection and protocol
*/
static void check_connection(Service_T s, Port_T p) {
Socket_T socket;
volatile int rv = TRUE;
char buf[STRLEN];
char report[STRLEN] = {0};
struct timeval t1;
struct timeval t2;
ASSERT(s && p);
/* Get time of connection attempt beginning */
gettimeofday(&t1, NULL);
/* Open a socket to the destination INET[hostname:port] or UNIX[pathname] */
socket = socket_create(p);
if (!socket) {
snprintf(report, STRLEN, "failed, cannot open a connection to %s", Util_portDescription(p, buf, sizeof(buf)));
rv = FALSE;
goto error;
} else
DEBUG("'%s' succeeded connecting to %s\n", s->name, Util_portDescription(p, buf, sizeof(buf)));
/* Verify that the socket is ready for i|o. TCP sockets are checked anytime, UDP
* sockets just when there is no specific protocol test used since the socket_is_ready()
* adds 2s delay when used with UDP socket. When there is specific protocol used, we
* don't need it for UDP, since the protocol test is sufficient */
if ((socket_get_type(socket) != SOCK_DGRAM || p->protocol->check == check_default) && !socket_is_ready(socket)) {
snprintf(report, STRLEN, "connection failed, %s is not ready for i|o -- %s", Util_portDescription(p, buf, sizeof(buf)), STRERROR);
rv = FALSE;
goto error;
}
/* Run the protocol verification routine through the socket */
if (! p->protocol->check(socket)) {
snprintf(report, STRLEN, "failed protocol test [%s] at %s", p->protocol->name, Util_portDescription(p, buf, sizeof(buf)));
rv = FALSE;
goto error;
} else
DEBUG("'%s' succeeded testing protocol [%s] at %s\n", s->name, p->protocol->name, Util_portDescription(p, buf, sizeof(buf)));
/* Get time of connection attempt finish */
gettimeofday(&t2, NULL);
/* Get the response time */
p->response = (double)(t2.tv_sec - t1.tv_sec) + (double)(t2.tv_usec - t1.tv_usec)/1000000;
error:
if (socket)
socket_free(&socket);
if (!rv) {
p->response = -1;
p->is_available = FALSE;
Event_post(s, Event_Connection, STATE_FAILED, p->action, report);
} else {
p->is_available = TRUE;
Event_post(s, Event_Connection, STATE_SUCCEEDED, p->action, "connection succeeded to %s", Util_portDescription(p, buf, sizeof(buf)));
}
}
/**
* Pass on to methods in http/cervlet.c to start/stop services
* @param P A service name as stated in the config file
* @param action A string describing the action to execute
*/
void d_check_service(const char *P, const char *action) {
Socket_T s;
char *auth= get_basic_authentication_header();
ASSERT(P);
ASSERT(action);
s= socket_new(Run.bind_addr?Run.bind_addr:"localhost",
Run.httpdport, SOCKET_TCP, Run.httpdssl);
if(!s) {
log("%s: Cannot connect to the monit daemon. "
"Did you start it with http support?\n", prog);
goto error;
} else {
socket_print(s, "GET /%s?action=%s HTTP/1.0\r\n%s\r\n", P, action, auth);
socket_free(&s);
}
error:
FREE(auth);
}
Socket_T socket_create_a(int socket, const char *remote_host,
int port, void *sslserver) {
Socket_T S;
ASSERT(socket>=0);
ASSERT(remote_host);
NEW(S);
S->length= 0;
S->offset= 0;
S->port= port;
S->socket= socket;
S->type= SOCK_STREAM;
S->timeout= NET_TIMEOUT;
S->host= xstrdup(remote_host);
S->connection_type= TYPE_ACCEPT;
if(sslserver) {
S->sslserver= sslserver;
if(! (S->ssl= insert_accepted_ssl_socket(S->sslserver))) {
goto ssl_error;
}
if(! embed_accepted_ssl_socket(S->ssl, S->socket)) {
goto ssl_error;
}
}
return S;
ssl_error:
socket_free(&S);
return NULL;
}
/**
* Post event or status data message to mmonit
* @param E An event object or NULL for status data
* @return If failed, return HANDLER_MMONIT flag or HANDLER_SUCCEEDED flag if succeeded
*/
int handle_mmonit(Event_T E) {
int rv = HANDLER_MMONIT;
Socket_T socket = NULL;
Mmonit_T C = Run.mmonits;
/* The event is sent to mmonit just once - only in the case that the state changed */
if (! C || (E && ! E->state_changed))
return HANDLER_SUCCEEDED;
StringBuffer_T sb = StringBuffer_create(256);
for (; C; C = C->next) {
if (! (socket = socket_create_t(C->url->hostname, C->url->port, SOCKET_TCP, C->ssl, C->timeout))) {
LogError("M/Monit: cannot open a connection to %s -- %s\n", C->url->url, STRERROR);
goto error;
}
status_xml(sb, E, E ? LEVEL_SUMMARY : LEVEL_FULL, 2, socket_get_local_host(socket));
if (! data_send(socket, C, StringBuffer_toString(sb))) {
LogError("M/Monit: cannot send %s message to %s\n", E ? "event" : "status", C->url->url);
goto error;
}
StringBuffer_clear(sb);
socket_shutdown_write(socket);
if (! data_check(socket, C)) {
LogError("M/Monit: %s message to %s failed\n", E ? "event" : "status", C->url->url);
goto error;
}
rv = HANDLER_SUCCEEDED; // Return success if at least one M/Monit succeeded
DEBUG("M/Monit: %s message sent to %s\n", E ? "event" : "status", C->url->url);
error:
if (socket)
socket_free(&socket);
}
StringBuffer_free(&sb);
return rv;
}
static void accept_ready(socket_t *socket, UNUSED_ATTR void *context) {
assert(socket != NULL);
assert(socket == listen_socket);
socket = socket_accept(socket);
if (!socket)
return;
client_t *client = (client_t *)osi_calloc(sizeof(client_t));
if (!client) {
LOG_ERROR(LOG_TAG, "%s unable to allocate memory for client.", __func__);
socket_free(socket);
return;
}
client->socket = socket;
if (!list_append(clients, client)) {
LOG_ERROR(LOG_TAG, "%s unable to add client to list.", __func__);
client_free(client);
return;
}
socket_register(socket, thread_get_reactor(thread), client, read_ready, NULL);
}
/* Close all sockets, free all the socket structs, and send a RST
* packet to clean up kernel state for each connection.
* TODO(ncardwell): centralize error handling and ensure test errors
* always result in a call to these clean-up functions, so we can make
* sure to reset connections in all cases.
*/
static void close_all_sockets(struct state *state)
{
struct socket *socket = state->sockets;
while (socket != NULL)
{
if (socket->live.fd >= 0 && !socket->is_closed)
{
assert(socket->script.fd >= 0);
DEBUGP("closing struct state socket "
"live.fd:%d script.fd:%d\n",
socket->live.fd, socket->script.fd);
if (close(socket->live.fd))
die_perror("close");
}
if (socket->protocol == IPPROTO_TCP &&
!state->config->is_wire_client &&
reset_connection(state, socket))
{
die("error reseting connection\n");
}
struct socket *dead_socket = socket;
socket = socket->next;
socket_free(dead_socket);
}
}
Display *OpenDisplay(char *hostname, int port)
{
Display *display = NULL;
Socket *socket = NULL;
char *port_buf = NULL;
port_buf = int_to_string(port);
if (port_buf == NULL)
return NULL;
socket = socket_new(Socket_Blocking);
if (socket_connect(socket, hostname, port_buf) != 0) {
socket_free(socket);
free(port_buf);
return NULL;
}
free(port_buf);
display = (Display *) malloc(sizeof(Display));
display->socket = socket;
display->hostname = strdup(hostname);
display->port = port;
display->callbacks = callbacks_new();
return display;
}
static void client_free(void *ptr) {
if (!ptr)
return;
client_t *client = (client_t *)ptr;
socket_free(client->socket);
osi_free(client);
}
PRIVATE socket_t *socket_udp6(uint32_t scope_id)
{
socket_t *s = socket_new6(scope_id);
if (s == NULL) {
return NULL;
}
#if defined(HAVE_LIBC_IPV6)
__winsock_init();
if (ip6disabled) {
goto compat;
}
s->fd = __winsock_errno(socket(PF_INET6, SOCK_DGRAM, IPPROTO_UDP));
if (s->fd == -1) {
if (errno == EINVAL ||
errno == EAFNOSUPPORT ||
errno == EPFNOSUPPORT ||
errno == EPROTONOSUPPORT) {
compat:
s->fd = __winsock_errno(socket(AF_INET, SOCK_DGRAM, 0));
ip6disabled = true;
if (s->fd == -1) {
socket_free(s);
return NULL;
}
}
if (s->fd == -1) {
socket_free(s);
return NULL;
}
return s;
}
#if defined(IPV6_V6ONLY)
int zero = 0;
__winsock_errno(setsockopt(s->fd, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&zero, sizeof(zero)));
#endif
if (socket_nodelay(s->fd) == -1) {
close(s->fd);
socket_free(s);
return NULL;
}
return s;
#else // HAVE_LIBC_IPV6
return s;
#endif
}
// Must be called with |lock| held except during teardown when we know the socket thread
// is no longer alive.
static void sco_socket_free_locked(sco_socket_t *sco_socket) {
if (!sco_socket)
return;
if (sco_socket->sco_handle != BTM_INVALID_SCO_INDEX)
BTM_RemoveSco(sco_socket->sco_handle);
socket_free(sco_socket->socket);
osi_free(sco_socket);
}
void hci_inject_close(void) {
socket_free(listen_socket);
list_free(clients);
thread_free(thread);
listen_socket = NULL;
thread = NULL;
clients = NULL;
}
/** Create an unbound Socket object.
*
* \param name name of the object, used for debugging
* \param is_tcp true if TCP, false for UDP XXX: This should be more generic
* \return a pointer to the SocketInt object, cast as a Socket, with a newly opened system socket
* \see socket_free, socket_close
*/
Socket* socket_new(char* name, int is_tcp) {
SocketInt* self = initialize(name);
self->is_tcp = is_tcp;
if (!s_socket(self)) {
socket_free((Socket*)self);
return NULL;
}
return (Socket*)self;
}
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;
}
int proxy_free(struct proxy *self)
{
assert(self);
assert(self->s);
socket_free(self->s);
free(self);
return 0;
}
PRIVATE socket_t *socket_udp4(void)
{
socket_t *s = socket_new4();
if (s == NULL) {
errno = EINVAL;
return NULL;
}
__winsock_init();
s->fd = __winsock_errno(socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP));
if (s->fd == -1) {
socket_free(s);
return NULL;
}
if (socket_nodelay(s->fd) == -1) {
close(s->fd);
socket_free(s);
return NULL;
}
return s;
}
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;
}
void client_destroy(int s)
{
client *c;
c = clients[s];
clients[s] = NULL;
socket_free(c->si);
buffer_free(c->buffer);
character_free(c->ch);
free(c);
}
/**
* Process a HTTP request. This is done by dispatching to the service
* function.
* @param s A Socket_T representing the client connection
*/
void *http_processor(Socket_T s) {
if(! can_read(socket_get_socket(s), REQUEST_TIMEOUT)) {
internal_error(s, SC_REQUEST_TIMEOUT, "Time out when handling the Request");
} else {
do_service(s);
}
socket_free(&s);
return NULL;
}
void client_destroy(client *c)
{
int fd;
fd = socket_get(c->si);
clients[fd] = NULL;
socket_free(c->si);
buffer_free(c->buffer);
character_free(c->ch);
free(c);
}
/** Do the actual writing into the OComm Socket, with error handling
* \param self OmlNetOutStream through which the data should be written
* \param buffer data to write
* \param length length of the data to write
*
* \return the size of data written, or -1 on error
*
* \see write(3)
*/
static ssize_t
socket_write(OmlOutStream* outs, uint8_t* buffer, size_t length)
{
OmlNetOutStream *self = (OmlNetOutStream*) outs;
int result = socket_sendto(self->socket, (char*)buffer, length);
if (result == -1 && socket_is_disconnected (self->socket)) {
logwarn ("%s: Connection lost\n", self->dest);
socket_free(self->socket);
self->socket = NULL; // Server closed the connection
}
return result;
}
int
socket(socket_family_t family, socket_type_t type, socket_protocol_t protocol)
{
if (m_initialization_state == false)
{
(void) socket_init();
}
VERIFY_MODULE_IS_INITIALIZED();
int ret_sock = -1;
int sock = socket_allocate();
SOCKET_TRACE("Got value %d from allocate\r\n", (int)sock);
if (sock >= 0)
{
socket_entry_t *p_socket_entry = &m_socket_table[sock];
p_socket_entry->handle.params.family = family;
p_socket_entry->handle.params.protocol = protocol;
p_socket_entry->handle.params.type = type;
p_socket_entry->handler = NULL;
if (family == AF_INET6)
{
#if SOCKET_IPV6_ENABLE == 1 || SOCKET_LWIP_ENABLE == 1
p_socket_entry->handler = &transport_handler;
#else
set_errno(EAFNOSUPPORT);
#endif
// } else if (family == AF_BLE) {
// TODO: Handle BLE
}
else
{
set_errno(EAFNOSUPPORT);
}
if (p_socket_entry->handler != NULL)
{
uint32_t err_code = p_socket_entry->handler->create_handler(&p_socket_entry->handle);
socket_set_errno(err_code);
ret_sock = (err_code == NRF_SUCCESS) ? sock : ret_sock;
}
if (ret_sock < 0)
{
socket_free(sock);
}
}
SOCKET_TRACE("Returning socket value %d\r\n", (int)ret_sock);
return ret_sock;
}
