Example #1
0
void sigint_handler(int signum)
{
    // do cleanups here and free all existing variables and stuff
    log_out("Closing client on: %d...\n", socket_get_fd(s));
    socket_close(s);
    exit(signum);
}
Example #2
0
/**
 * netplay_new:
 * @server               : IP address of server.
 * @port                 : Port of server.
 * @frames               : Amount of lag frames.
 * @cb                   : Libretro callbacks.
 * @spectate             : If true, enable spectator mode.
 * @nick                 : Nickname of user.
 *
 * Creates a new netplay handle. A NULL host means we're
 * hosting (user 1).
 *
 * Returns: new netplay handle.
 **/
netplay_t *netplay_new(const char *server, uint16_t port,
                       unsigned frames, const struct retro_callbacks *cb,
                       bool spectate,
                       const char *nick)
{
    netplay_t *netplay = NULL;

    if (frames > UDP_FRAME_PACKETS)
        frames = UDP_FRAME_PACKETS;

    netplay = (netplay_t*)calloc(1, sizeof(*netplay));
    if (!netplay)
        return NULL;

    netplay->fd                = -1;
    netplay->udp_fd            = -1;
    netplay->cbs               = *cb;
    netplay->port              = server ? 0 : 1;
    netplay->spectate.enabled  = spectate;
    netplay->is_server         = server == NULL;
    strlcpy(netplay->nick, nick, sizeof(netplay->nick));

    if(spectate)
        netplay->net_cbs = netplay_get_cbs_spectate();
    else
        netplay->net_cbs = netplay_get_cbs_net();

    if (!init_socket(netplay, server, port))
    {
        free(netplay);
        return NULL;
    }

    if(!netplay_info_cb(netplay, frames))
        goto error;

    return netplay;

error:
    if (netplay->fd >= 0)
        socket_close(netplay->fd);
    if (netplay->udp_fd >= 0)
        socket_close(netplay->udp_fd);

    free(netplay);
    return NULL;
}
Example #3
0
void
udp_detach(struct socket *so)
{
	socket_close(so->s);
	/* if (so->so_m) m_free(so->so_m);    done by sofree */

	sofree(so);
}
void ThreadedSocketConnection::disconnect()
{ QF_STACK_PUSH(ThreadedSocketConnection::disconnect)
  
  m_disconnect = true;
  socket_close( m_socket );

  QF_STACK_POP
}
Example #5
0
/*
 * Used to kill the server properly when receiving SIGINT (^C).
 * TODO : this function should also kill all living sons of the main process,
 * and close the associated sockets.
 * (Should we store their pids in a global array ?)
 */
static void 
kill_server (int signum)
{
    /* Dummy assignment to shut the compiler up */
    signum = signum;
    socket_close (server_socket);
    exit (EXIT_SUCCESS);
}
/** Deinitialize and free Netplay discovery */
void deinit_netplay_discovery(void)
{
   if (lan_ad_client_fd >= 0)
   {
      socket_close(lan_ad_client_fd);
      lan_ad_client_fd = -1;
   }
}
void irc_disconnect (irc_session_t * session)
{
	if ( session->sock >= 0 )
		socket_close (&session->sock);

	session->sock = -1;
	session->state = LIBIRC_STATE_INIT;
}
Example #8
0
static int net_http_new_socket(const char *domain, int port)
{
   int fd;
#ifndef _WIN32
   struct timeval timeout;
#endif
   struct addrinfo hints, *addr = NULL;
   char portstr[16] = {0};

   snprintf(portstr, sizeof(portstr), "%i", port);

   memset(&hints, 0, sizeof(hints));
   hints.ai_family   = AF_UNSPEC;
   hints.ai_socktype = SOCK_STREAM;
   hints.ai_flags    = 0;

   if (getaddrinfo_rarch(domain, portstr, &hints, &addr) < 0)
      return -1;
   if (!addr)
      return -1;

   fd = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);

#ifndef _WIN32
   timeout.tv_sec=4;
   timeout.tv_usec=0;
   setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, (char*)&timeout, sizeof timeout);
#endif

   if (connect(fd, addr->ai_addr, addr->ai_addrlen) != 0)
   {
      freeaddrinfo_rarch(addr);
      socket_close(fd);
      return -1;
   }

   freeaddrinfo_rarch(addr);

   if (!socket_nonblock(fd))
   {
      socket_close(fd);
      return -1;
   }

   return fd;
}
Example #9
0
void ssl_socket_close(void *state_data)
{
   struct ssl_state *state = (struct ssl_state*)state_data;

   mbedtls_ssl_close_notify(&state->ctx);

   socket_close(state->net_ctx.fd);
}
Example #10
0
void server_pensionerHtmlID(socket_t * client, resource_t * lt, http_request_t * req)
{
    char buf[10000] = "";
    char * p = strstr(req->uri, "/pensioners/");
    p = p + 12;
    int index = atoi(p);

    if(index >= 0)
    {
        for(int i = 0; i < resource_getCnt(lt); i++)
        {
            if(index == resource_getID(lt, i))
            {
                if(strcmp(req->method, "GET") == 0)
                {
                    char pText[1000] = "";
                    char * text = pensioner_toHTML(resource_getbyId(lt, index), index);
                    strcat(pText, text);

                    char * pageText = "<a href=\"http://127.0.0.1:5000/pensioners\"><br>Back to the list.</a>";
                    strcat(pText, pageText);

                    char * textHtml = textToBuf_HTML(pText);
                    strcat(buf, textHtml);
                    free(textHtml);
                }
                else if(strcmp(req->method, "DELETE") == 0)
                {
                    char pText[1000] = "";
                    char * text = pensioner_toHTML(resource_deletePens(lt, index), index);
                    strcat(pText, text);
                    free(text);

                    sprintf(buf,
                            "HTTP/1.1 200 OK\n"
                            "Access-Control-Allow-Origin: *\n"
                            "Access-Control-Allow-Methods: DELETE\n"
                            "\n");
                }
            }
        }
        char * message = "<h3 style=\"color:orange\">ID not found!</h3>";
        char * textHtml = textToBuf_HTML(message);
        strcat(buf, textHtml);
        free(textHtml);

    }
    else
    {
        char * message = "<h3 style=\"color:orange\">ID not found!</h3>";
        char * textHtml = textToBuf_HTML(message);
        strcat(buf, textHtml);
        free(textHtml);

    }
    socket_write_string(client, buf);
    socket_close(client);
}
Example #11
0
static void server_post(http_request_t request, socket_t* client, leading_t** leadings){
    int id = 0;
    int count = leading_leadingsCount(leadings);
    char buffer[2000] ="";
    char* str;
    char* name = http_request_getArg(&request, "name");
    char* surname = http_request_getArg(&request, "surname");
    char* birthdate = http_request_getArg(&request, "birthdate");
    char* experience = http_request_getArg(&request, "experience");
    char* rating = http_request_getArg(&request, "rating");

    if(strlen(name) <= 1 || strlen(surname) <= 1 || strlen(birthdate) <= 1){
        server_send(client, "Name/Surname/Birthday wasn't filled in"
                            "<p><a href=\"/leadings/new/\">Back to POST</a></p>");
        return;
    }

    str = birthdate;

   if(strlen(birthdate) > 10 || str[4] != '-' || str[7] != '-' || isdigit(birthdate[0])==0 || isdigit(experience[0]) == 0 || isdigit(rating[0])==0){
        server_send(client, "Wrong data!"
                    "<p><a href=\"/leadings/new/\">Back to POST</a></p>");
        return;
    }

    if(experience == " ")
        experience = "0";

    if(rating == " ")
        rating = "0.0";

    if(count >= MAX_LEADINGS){
        char fail[] = "Limit of leadings!";
        sprintf(buffer,
            "HTTP/1.1 404 \n"
            "Content-Type: text\n"
            "Content-Length: %i\r\n\r\n"
            "\n%s", strlen(fail), fail);

        socket_write_string(client, buffer);
        socket_close(client);
        return;
    }

    for(int i = 0; i<MAX_LEADINGS; i++, id++)
    {
        if(leading_getId(leadings[i]) == -1)
            break;
    }

    int exp = atoi(experience);
    double rate = atof(rating);

    leading_fill(leadings[id], id, name, surname, birthdate, exp, rate);
    server_send(client, "Success"
                "<p><a href=\"/leadings/\">All leadings</a></p>");

}
Example #12
0
int socket_tcp_listen(const char *hostname, const char *port) {
	// NULL port / service name is not accepted.
	// NULL hostname is OK. (== bind to any interface)
	if (!port) {
		return -1;
	}

	struct addrinfo *address, hints;
	memset(&hints, 0, sizeof(hints));
	hints.ai_family = AF_INET6;
	hints.ai_socktype = SOCK_STREAM;
	hints.ai_flags = AI_PASSIVE | AI_ALL | AI_V4MAPPED;

	int r = -1;	
	if (0 != (r = getaddrinfo(hostname, port, &hints, &address))) {
		return -1;
	}
	int fd = -1;
	for (struct addrinfo *iter = address; iter; iter = iter->ai_next) {
		if (-1 == (fd = socket(iter->ai_family, iter->ai_socktype, address->ai_protocol))) {
			perror("socket");
			continue;
		}
		int yes = 1;
		if (-1 == setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes))) {
			perror("setsockopt");
			socket_close(&fd);
			continue;
		}
		if (-1 == bind(fd, iter->ai_addr, iter->ai_addrlen)) {
			perror("bind");
			socket_close(&fd);
			continue;
		}
		if (-1 == listen(fd, 128)) {
			perror("listen");
			socket_close(&fd);
		}
		// Success
		break;
	}
	freeaddrinfo(address);

	return fd;
}
Example #13
0
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;
}
Example #14
0
int main(int argc, char* argv[]) {
  gint error = 0;
  options_init(argc - 1, argv + 1);

  INFO("Starting up.");
  descriptor_init();

  DEBUG("Disabling SIGPIPE.");
  signal(SIGPIPE, SIG_IGN);

  DEBUG("Creating ZeroMQ context.");
  gpointer zmq_context = zmq_init(options_zmq_io_threads());
  if (zmq_context == NULL) {
    PERROR("main(zmq_init)");
    error = 1;
    goto err0;
  }

  DEBUG("Creating server on port %s.", options_port());
  gint socket = socket_server(options_port());
  if (socket == -1) {
    error = 1;
    goto err1;
  }

  INFO("Initialising Lua API.");
  lua_api_init(zmq_context, argc - 1, argv + 1);
  lua_State* lua = lua_api_get();
  DEBUG("Running " LUA_START_FILE);
  if (luaL_dofile(lua, LUA_START_FILE) == 1) {
    ERROR("%s", lua_tostring(lua, -1));
    error = 1;
    goto err2;
  }

  io_mainloop(socket);

 err2:
  DEBUG("Closing server socket.");
  socket_close(socket);
 err1:
  DEBUG("Terminating ZeroMQ context.");
  /* This is separate from lua_api_deinit() to prevent zmq_term() from
     blocking forever. */
  lua_zmq_deinit();
  zmq_term(zmq_context);
 err0:
  DEBUG("Enabling SIGPIPE.");
  signal(SIGPIPE, SIG_DFL);
  options_deinit();
  descriptor_deinit();
  if (lua_api_get() != NULL) {
    DEBUG("Closing Lua state.");
    lua_api_deinit();
  }
  return error;
}
Example #15
0
void listener_release(struct listener *self) {
	assert(self != NULL);
	assert(!self->isfree);
	if (!self)
		return;
	socket_close(&self->sockfd);
	self->isfree = true;
	netpool_releaselisten(self);
}
Example #16
0
static int
st_local_socket_close(int sd)
{
	if (!use_obp) {
		return (socket_close(sd));
	} else {
		return (0);
	}
}
Example #17
0
void player_close(player_info_t *player) {
	socket_close(player->socket);
	if ( player == players ) {
		players = player->next;
	} else {
		player->prev->next = player->next;
	}
	free(player);
}
Example #18
0
void net_http_delete(struct http_t *state)
{
   if (!state)
      return;

   if (state->fd >= 0)
      socket_close(state->fd);
   free(state);
}
Example #19
0
static void ClientNetworkLayerClose(UA_Connection *connection) {
    if(connection->state == UA_CONNECTION_CLOSED)
        return;
    connection->state = UA_CONNECTION_CLOSED;
    socket_close(connection);
#ifndef UA_MULTITHREADING
    UA_ByteString_delete(connection->handle);
#endif
}
Example #20
0
int ipc_server_close(int fd, int last_error)
{
    int ret = 0;
    
    if (!last_error)
	ret = ipc_server_sync(fd);
    socket_close(fd);
    return ret;
}
Example #21
0
void rarch_cmd_free(rarch_cmd_t *handle)
{
#if defined(HAVE_NETWORK_CMD) && defined(HAVE_NETPLAY)
   if (handle && handle->net_fd >= 0)
      socket_close(handle->net_fd);
#endif

   free(handle);
}
static int tcp_close(FdMigrationState *s)
{
    dprintf("tcp_close\n");
    if (s->fd != -1) {
        socket_close(s->fd);
        s->fd = -1;
    }
    return 0;
}
Example #23
0
static int socket_dev_close(dev_cookie cookie)
{
	socket_dev *s = (socket_dev *)cookie;

	if(s->id >= 0)
		return socket_close(s->id);
	else
		return 0;
}
Example #24
0
/*
 * Test a single listening socket.  Accepts one connection and invokes
 * test_server_connection.  For skipping purposes, this produces two tests.
 */
static void
test_server_accept(socket_type fd)
{
    socket_type client;

    client = accept(fd, NULL, NULL);
    test_server_connection(client);
    socket_close(fd);
}
Example #25
0
void pbpal_free(pubnub_t *pb)
{
    if (pb->pal.socket != SOCKET_INVALID) {
        /* While this should not happen, it doesn't hurt to be paranoid.
         */
        pbntf_lost_socket(pb, pb->pal.socket);
        socket_close(pb->pal.socket);
    }
}
Example #26
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;
}
Example #27
0
/**
unsigned short  get_valid_rtp_pair_sockets(int min, int max, int* rtp, int* rtcp)

min〜max でランダムなポート番号を持った RTPとRTCPのソケットを生成する.

@param  min  使用可能なポート番号の最小値
@param  max  使用可能なポート番号の最大値
@param  rtp  RTP のソケット番号が入る.
@param  rtcp RTCPのソケット番号が入る.

@return RTPのポート番号(偶数).RTCPのポート番号は + 1 する.
*/
unsigned short  get_valid_rtp_pair_sockets(int min, int max, int* rtp, int* rtcp)
{
	int  i = 1;
	int  range, sock1, sock2, port;

	max = max - 1;
	min = min + 1;

	range = max - min + 1;
	port  = ((rand()%range + min)/2)*2;

	sock1 = udp_server_socket(port);			// RTP
	sock2 = udp_server_socket(port+1);			// RTCP
	if (sock1<=0 || sock2<=0) {
		if (sock1>0) socket_close(sock1);
		if (sock2>0) socket_close(sock2);
		sock1 = sock2 = 0;
	}

	while(sock1==0 && i<range) {
		port = port + 2;
		if (port>max) port = ((port%max + min - 1)/2)*2;

		sock1 = udp_server_socket(port);		// RTP
		sock2 = udp_server_socket(port+1);		// RTCP
		if (sock1<=0 || sock2<=0) {
			if (sock1>0) socket_close(sock1);
			if (sock2>0) socket_close(sock2);
			sock1 = sock2 = 0;
		}
		i = i + 2;
	}

	if (sock1==0) {
		port = 0;
		*rtp = *rtcp =0;
	}
	else {
		*rtp  = sock1;
		*rtcp = sock2;
	}
	
	return (unsigned short)port;
}   
Example #28
0
void server_file_parse(socket_t * client){
        char html_doc[15000];
    char * filename = {"C:\\Users\\User\\Desktop\\samokh-52\\courses\\prog_base_2\\tests\\test_2\\Server_kr_app\\files\\filename.txt"};
    if(file_exists(filename)){
    char text[10000];
    char buf[1000];
    char ContentToReceive[10000];
    memset(ContentToReceive, '\0', 10000);
    FILE *f = fopen(filename, "r");
    char *word;
    int i = 0, j = 0;
    char html_text[15000] ="<!DOCTYPE html> <html> <head>List</head> <body><ol type=\"1\">";
    while(fgets(buf, 1000, f) != NULL)
		{
			strcat(ContentToReceive, buf);
		}
    word = strtok(ContentToReceive, " ");
    while(word != NULL){
        /*j = 0;
        while(ContentToReceive[i] != ' '){
            word[j] = ContentToReceive[i];
            j++;
            i++;
        }*/
        
        strcat(html_text, "<li>");
        strcat(html_text, word);
        strcat(html_text, "</li>");
        puts(word);
        word = strtok(NULL, " ");
    }
    puts("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
    strcat(html_text, "</ol>");
    strcat(html_text, "</body> </html>");
    sprintf(html_doc,
        "HTTP/1.1 200 OK\n"
        "Content-Type: text/html\n"
        "Content-Length: %u\n"
    "\n%s", strlen(html_text), html_text);
    
    }
    else if(!file_exists(filename)){
        char html_text[15000] ="<!DOCTYPE html> <html> <head>File does`not exist</head> <body><ol type=\"1\">";
        
        strcat(html_text, "</body> </html>");
        char html_doc[15000];
        sprintf(html_doc,
        "HTTP/1.1 200 OK\n"
        "Content-Type: text/html\n"
        "Content-Length: %u\n"
        "\n%s", strlen(html_text), html_text);
    }
    socket_write_string(client, html_doc);
    socket_close(client);
    
}
Example #29
0
void server_mastersByID(socket_t * client, http_request_t * req, db_t * db)
{
    char buffer[10240] = "";

    char * point = strstr(req->uri, "/api/ScrumMasters/");
    point += 18;
    int index = atoi(point);

    if(0 < index && index < db_count(db) + 1)
    {
        if (strcmp(req->method, "GET") == 0)
        {
            master_t * master = db_getDataById(db, index - 1);

            cJSON * jText = cJSON_CreateObject();
            cJSON_AddItemToObject(jText, "Name", cJSON_CreateString(master_getName(master)));
            cJSON_AddItemToObject(jText, "Surname", cJSON_CreateString(master_getSurname(master)));
            cJSON_AddItemToObject(jText, "CountK", cJSON_CreateNumber(master_getCountK(master)));
            cJSON_AddItemToObject(jText, "CountP", cJSON_CreateNumber(master_getCountP(master)));
            char * pageText = cJSON_Print(jText);

            free(master);

            char * textJSON = textToJSON(pageText);
            strcat(buffer, textJSON);
            free(textJSON);
        }
        else if (strcmp(req->method, "DELETE") == 0)
        {
            master_t * master = db_getDataById(db, index - 1);
            db_deleteData(db, master_getID(master));
            free(master);

            cJSON * jText = cJSON_CreateObject();
            cJSON_AddItemToObject(jText, "Success", cJSON_CreateString("Successfully deleted"));
            char * pageText = cJSON_Print(jText);

            char * textJSON = textToJSON(pageText);
            strcat(buffer, textJSON);
            free(textJSON);
        }
    }
    else
    {
        cJSON * jText = cJSON_CreateObject();
        cJSON_AddItemToObject(jText, "Error", cJSON_CreateString("ID Not Found"));
        char * pageText = cJSON_Print(jText);

        char * textJSON = textToJSON(pageText);
        strcat(buffer, textJSON);
        free(textJSON);
    }

    socket_write_string(client, buffer);
    socket_close(client);
}
Example #30
0
static void
sys_channel_free( SysChannel  channel )
{
    if (channel->fd >= 0) {
        socket_close( channel->fd );
        channel->fd = -1;
    }
    channel->next    = _s_free_channels;
    _s_free_channels = channel;
}