void *thread_main(void *arg)
{
    int fd;
    char * spath = (char *) arg;
    char *tile;

    fd = connect_socket(spath);

    while((tile = fetch(spath, &fd))) {
        int ret = process(fd, tile);
        if (ret == 0) {
            printf("Reconnecting closed socket\n");
            close(fd);
            fd = connect_socket(spath);
        }
        num_render++;
        if (!(num_render % 10)) {
            gettimeofday(&end, NULL);
            printf("\n");
            printf("Meta tiles rendered: ");
            display_rate(start, end, num_render);
            printf("Total tiles rendered: ");
            display_rate(start, end, num_render * METATILE * METATILE);
            printf("Number of Metatiles tested for expiry: ");
            display_rate(start, end, num_all);
            printf("\n");
        }
        free(tile);
    }

    close(fd);

    return NULL;
}

static void test_connect_two_sockets(const void *test_data)
{
	struct test_data *data = tester_get_data();
	const struct l2cap_data *l2data = data->test_data;
	const uint8_t *client_bdaddr;

	test_two_sockets_connect_cb_cnt = 0;
	test_scan_enable_counter = 0;

	hciemu_add_master_post_command_hook(data->hciemu,
				test_connect_two_sockets_router, data);

	if (l2data->server_psm) {
		struct bthost *bthost = hciemu_client_get_host(data->hciemu);

		if (!l2data->data_len)
			bthost_add_l2cap_server(bthost, l2data->server_psm,
						NULL, NULL);
	}

	client_bdaddr = hciemu_get_client_bdaddr(data->hciemu);
	if (l2data->close_one_socket)
		connect_socket(client_bdaddr, &data->sk, NULL);
	else
		connect_socket(client_bdaddr, &data->sk,
						test_two_sockets_connect_cb);
}

static IPC_SOCKET_TYPE connect_and_serve(const char *socket_path, const char* event_path, const char *exec_path)
{
  IPC_SOCKET_TYPE sock = connect_socket(socket_path, 0);

  if (sock == INVALID_HANDLE_VALUE)
  {
    start_server(socket_path, event_path, exec_path);
    sock = connect_socket(socket_path, 1);
  }

  if (sock == INVALID_HANDLE_VALUE)
    abort();

  return sock;
}

int main(int argc, char **argv) 
{
		SOCKET sock = connect_socket(IP_ADDR, PORT);
		BOOL must_continue = sock != INVALID_SOCKET;
		
		char buf[MAXLINE];
		char* prompt = "sldb> ";
		while( must_continue ){
			//snprintf(buf, MAXLINE, "?1 ? ?\r\n");
			
			write(STDOUT_FILENO, prompt, strlen(prompt));
      int n_readed = read(STDIN_FILENO, buf, MAXLINE);
			must_continue &= !send_socket(sock, buf, n_readed);
			
			while( must_continue ){
				int len = read_line(sock, buf, MAXLINE);
				BOOL is_empty_line = len == 0;
				if( is_empty_line ){
					break;
				}
				write(STDOUT_FILENO, buf, len);
				printf("\r\n");
				BOOL must_close = !strcmp(buf, "!close");
				must_continue &= !must_close;
			}
		}
		
		int iResult = close_socket(sock);
    return iResult;
}

int websocket_connect(websocket_t *client, char *host, const char *port)
{
	int r;
	int tls_hs_retry = WEBSOCKET_MAX_TLS_HANDSHAKE;

TLS_HS_RETRY:
	if ((r = connect_socket(client, host, port)) != WEBSOCKET_SUCCESS) {
		return r;
	}

	if (websocket_config_socket(client->fd) != WEBSOCKET_SUCCESS) {
		WEBSOCKET_CLOSE(client->fd);
		return WEBSOCKET_SOCKET_ERROR;
	}

	if (client->tls_enabled) {
		if ((r = websocket_tls_handshake(client, host, client->auth_mode)) != WEBSOCKET_SUCCESS) {
			if (r == MBEDTLS_ERR_NET_SEND_FAILED || r == MBEDTLS_ERR_NET_RECV_FAILED || r == MBEDTLS_ERR_SSL_CONN_EOF) {
				if (tls_hs_retry-- > 0) {
					WEBSOCKET_DEBUG("Handshake again.... \n");
					mbedtls_net_free(&(client->tls_net));
					mbedtls_ssl_free(client->tls_ssl);
					mbedtls_ssl_init(client->tls_ssl);
					goto TLS_HS_RETRY;
				}
			}
			return WEBSOCKET_TLS_HANDSHAKE_ERROR;
		}
	}
	return r;
}

/* Select handler which is set for the socket descriptor when connect() has
 * indicated (via errno) that it is in progress. On completion this handler gets
 * called. */
static void
connected(struct socket *socket)
{
	int err = 0;
	struct connection_state state = connection_state(0);
	socklen_t len = sizeof(err);

	assertm(socket->connect_info != NULL, "Lost connect_info!");
	if_assert_failed return;

	if (getsockopt(socket->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len) == 0) {
		/* Why does EMX return so large values? */
		if (err >= 10000) err -= 10000;
		if (err != 0)
			state = connection_state_for_errno(err);
		else
			state = connection_state(0);
	} else {
		/* getsockopt() failed */
		if (errno != 0)
			state = connection_state_for_errno(errno);
		else
			state = connection_state(S_STATE);
	}

	if (!is_in_state(state, 0)) {
		/* There are maybe still some more candidates. */
		connect_socket(socket, state);
		return;
	}

	complete_connect_socket(socket, NULL, NULL);
}

/* DNS callback. */
static void
dns_found(struct socket *socket, struct sockaddr_storage *addr, int addrlen)
{
	struct connect_info *connect_info = socket->connect_info;
	int size;

	if (!addr) {
		socket->ops->done(socket, connection_state(S_NO_DNS));
		return;
	}

	assert(connect_info);

	size = sizeof(*addr) * addrlen;

	connect_info->addr = mem_alloc(size);
	if (!connect_info->addr) {
		socket->ops->done(socket, connection_state(S_OUT_OF_MEM));
		return;
	}

	memcpy(connect_info->addr, addr, size);
	connect_info->addrno = addrlen;

	/* XXX: Passing non-result state here is bad but a lack of alternatives
	 * makes it so. Well adding get_state() socket operation could maybe fix
	 * it but the returned state would most likely be a non-result one at
	 * this point in the connection lifecycle. This will, however, only be a
	 * problem if connect_socket() fails without doing any system calls
	 * which is only the case when forcing the IP family. So it is better to
	 * handle it in connect_socket(). */
	connect_socket(socket, connection_state(S_CONN));
}

int main(int argc, char** argv) {
    if (argc < 3) {
        printf("Usage: jattach <pid> <cmd> <args> ...\n");
        return 1;
    }
    
    int pid = atoi(argv[1]);
    if (!check_socket(pid) && !start_attach_mechanism(pid)) {
        printf("Could not start attach mechanism\n");
        return 1;
    }

    int fd = connect_socket(pid);
    if (fd == -1) {
        printf("Could not connect to socket\n");
        return 1;
    }
    
    printf("Connected to remote JVM\n");
    write_command(fd, argc - 2, argv + 2);

    printf("Response code = ");
    read_response(fd);

    printf("\n");
    close(fd);
    
    return 0;
}

int main(int argc, char ** argv)
{
    int   sockfd=0;
    char  sendMsg[30]="abc.org/r/n/r";
    char* res;
    int   port = 4242;
    char  ip[128] = {0};
    strncpy(ip, "127.0.0.1", 128);
    if(argc > 2)
    {
        strncpy(ip, argv[1], 128);
        port = atoi(argv[2]);
        printf("Input IP: %s, port : %d/n", ip, port);
    }
    else if(argc > 1)
    {
        port = atoi(argv[1]);
        printf("Input port : %d/n", port);
    }
    sockfd=connect_socket(ip, port);

    send_msg(sockfd,sendMsg);
    /* res=recv_msg(sockfd); */

    printf("return from recv function/n");
    printf(res);
    free(res);
    close_socket(sockfd);
    return 0;
}

// Initialize resources for the node
void IPC_initialize_node(int _node_id)
{
  node_id = _node_id;

  if (node_id == 0)
  {
    sock = (typeof(sock)) malloc(sizeof(*sock) * nb_nodes);
    if (!sock)
    {
      perror("sock allocation error");
      exit(-1);
    }

    sock[0] = create_socket(PORT_CORE_0, nb_nodes);

    for (int i = 1; i < nb_nodes; i++)
    {
      sock[i] = get_connection(sock[0]);
    }
  }
  else
  {
    sock = (typeof(sock)) malloc(sizeof(*sock));
    if (!sock)
    {
      perror("sock allocation error");
      exit(-1);
    }

    sock[0] = create_socket(0, 0);
    connect_socket(sock[0], PORT_CORE_0);
  }
}

int main (int argc, char *argv[]) {

  // Exit nicely
  struct sigaction sigIntHandler;

  sigIntHandler.sa_handler = my_handler;
  sigemptyset(&sigIntHandler.sa_mask);
  sigIntHandler.sa_flags = 0;

  sigaction(SIGINT, &sigIntHandler, NULL);
  // / Exit nicely

  if( argc < 2 ){
    printf("Usage: %s ServerAdresse\n", *argv);
    exit(EXIT_FAILURE);
  }

  sock = create_socket(AF_INET6, SOCK_STREAM, 0);
  atexit(cleanup);
  connect_socket(&sock, argv[1], 15000);

  pthread_t tw;
  pthread_create(&tw,NULL,sender,NULL);

  pthread_t tr;
  pthread_create(&tr,NULL,listener,NULL);

  pthread_join(tw,NULL);
  pthread_join(tr,NULL);

  return EXIT_SUCCESS;
}

apisock *api_connect_ssl(){
  apisock *ret;
  SSL *ssl;
  int sock;
  sock=connect_socket(API_HOST, API_PORT_SSL);
  if (sock==-1)
    return NULL;
  if (!globalctx){
    SSL_library_init();
    OpenSSL_add_all_algorithms();
    OpenSSL_add_all_ciphers();
    SSL_load_error_strings();
    globalctx=SSL_CTX_new(SSLv23_method());
    if (!globalctx)
      return NULL;
  }
  ssl=SSL_new(globalctx);
  if (!ssl){
    close(sock);
    return NULL;
  }
  SSL_set_fd(ssl, sock);
  if (SSL_connect(ssl)!=1){
    SSL_free(ssl);
    close(sock);
    return NULL;
  }
  ret=(apisock *)malloc(sizeof(apisock));
  ret->sock=sock;
  ret->ssl=ssl;
  return ret;
}

void Socket::create_and_connect()
{
    addrinfo* serverinfo;
    int res;

    if ((res = get_addr_info(&serverinfo)) != 0)
    {
        throw std::system_error(errno, std::system_category(),
                                REPORT_ERROR("getaddrinfo failure: " +
                                std::string(gai_strerror(res))));
    }

    try
    {
        create_socket(serverinfo);
        connect_socket(serverinfo);
    }
    catch (std::system_error const& err)
    {
        freeaddrinfo(serverinfo);
        close(sock);
        throw err;
    }

    freeaddrinfo(serverinfo);

    if (!server_info.password.empty())
        send_to_socket("PASS " + server_info.password + "\r\n");

    send_to_socket("NICK " + server_info.nick + "\r\n");
    send_to_socket("USER " + server_info.user + "\r\n");
}

void *FUNC_THREAD(void *threadid)
{
    FILE *dosya_yaz;
    dosya_yaz = fopen("userlist.txt","a");
    long tid;
    tid = (long)threadid;
    
    char str[20];
    sprintf(str,"192.168.2.%ld",(tid+1));
    
    int conn;
    conn = connect_socket(10001,str);
    char inbuffer[512];
    if (conn != -1)
	{
		recv(conn,inbuffer,512,0);
		fprintf(dosya_yaz,"%s %s\n",str,inbuffer);
		
	}
	   
    close(conn);
    
    fclose(dosya_yaz);
    pthread_exit(NULL);
}

int sanlock_request(uint32_t flags, uint32_t force_mode,
		    struct sanlk_resource *res)
{
	int fd, rv, datalen;

	datalen = sizeof(struct sanlk_resource) +
		  sizeof(struct sanlk_disk) * res->num_disks;

	rv = connect_socket(&fd);
	if (rv < 0)
		return rv;

	rv = send_header(fd, SM_CMD_REQUEST, flags, datalen, force_mode, 0);
	if (rv < 0)
		goto out;

	rv = send(fd, res, sizeof(struct sanlk_resource), 0);
	if (rv < 0) {
		rv = -errno;
		goto out;
	}

	rv = send(fd, res->disks, sizeof(struct sanlk_disk) * res->num_disks, 0);
	if (rv < 0) {
		rv = -errno;
		goto out;
	}

	rv = recv_result(fd);
 out:
	close(fd);
	return rv;
}

int
send_request(Request req)
{
	if (! req->socket ) {
		req->socket = connect_socket(req->host,req->port,0);
		if (! req->socket) {
			error("Failed to connect to %s:%i\n",req->host,req->port);
			return 0;
		}
		add_req_socket(req->socket->fd);
		return 0;
	}
	if (req->length < 0) {
		str cmd = _("%s %s HTTP/1.1\r\n",req->method,req->path);
		write_socket(req->socket,cmd);
		request_headers(req,_("Host"),req->host);
		send_headers(req->socket,req->headers);
		req->length = outbound_content_length(req->contents,req->raw_contents);	
		return req->contents != NULL || req->raw_contents != NULL ;
	}
	req->written += req->contents ?
			send_contents(req->socket,req->contents,is_chunked(req->headers)) :
		req->raw_contents ?
			send_raw_contents(req->socket,req->raw_contents,req->written,0):
			0;
	if (is_chunked(req->headers) && req->written >= req->length)
		write_chunk(req->socket,NULL,0);
	return req->written < req->length;
}

static int op_setopt (void *impl, const char *option,
                      const void *val, size_t size)
{
    ctx_t *ctx = impl;
    assert (ctx->magic == MODHANDLE_MAGIC);
    size_t val_size;
    int rc = -1;

    if (option && !strcmp (option, FLUX_OPT_ZEROMQ_CONTEXT)) {
        val_size = sizeof (ctx->zctx);
        if (size != val_size) {
            errno = EINVAL;
            goto done;
        }
        memcpy (&ctx->zctx, &val, val_size);
        if (connect_socket (ctx) < 0)
            goto done;
    } else {
        errno = EINVAL;
        goto done;
    }
    rc = 0;
done:
    return rc;
}

/*
  Fork lgmon's process - for LPR(ng) system

       lm_main_lpr()        : parent process.
       data_output_process(): print data output process.
       status_get_process() : print status read process.
*/
static void lm_main_fork_lpr()
{
	char *nbuf;

	if((stmon_pid = fork())){
		int server_fd  = 0;
		int sm_sock_fd = 0;

		/* create socket and connect LM<->SM */
		if(connect_socket(&server_fd, &sm_sock_fd) < 0){
			/* socket error */

			if(server_fd > 0)
				close(server_fd);
			if(sm_sock_fd > 0)
				close(sm_sock_fd);

			kill(stmon_pid, SIGTERM);
			goto lm_exit;
		}

		if((stat_pid = fork())){
			if((data_pid = fork())){
				/* LM main process */

				/* exec lgmon main process */
				lm_main_lpr(sm_sock_fd);
				close(sm_sock_fd);
				close(server_fd);
			}
			else
				/* print data output process */
				data_output_process(sm_sock_fd); /* never return */
		}
		else
			/* printer status get process */
			status_get_process(sm_sock_fd); /* never return */
	}
	else{
		nbuf = (char *)malloc ((strlen (STMON_PATH)+strlen (PACKAGE)+2));
		if (nbuf == NULL)
			exit (0);
		
		memset((void*)nbuf, 0, (strlen (STMON_PATH)+strlen (PACKAGE)+1));
		strncpy(nbuf, STMON_PATH, strlen (STMON_PATH) );
		strncat(nbuf, "/", strlen("/"));
		strncat(nbuf, PACKAGE, strlen(PACKAGE));
		/* status monitor process */
		if(execv(nbuf, stamon_arg) < 0){
#ifdef DEBUG
			write_log("SM execv error\n");
#endif
		}
		exit(0); /* never arrive this point */
	}

lm_exit:
	return;
}

int main (int argc, char *argv[]) {
	if (argc < 3) {
		fprintf (stderr, "Usage: ./client ip_server port_server\n");
		exit (EXIT_FAILURE);
	}
	connect_socket (argv[1], atoi (argv[2]));
	return 0;
}

int main(int argc, char *argv[])
{
	SSL_CTX *ctx;
	const SSL_METHOD *method = SSLv3_client_method();
	int client_fd;
	char *host;
	char *portnum;
	int bench_send = 0;
	int bench_recv = 0;
	int i;
	enum cipher_choice cipher_choice = CIPHER_ALL;

	if (argc < 3) {
		printf("Usage: %s <host_ip> <portnum> [opts]\n", argv[0]);
		exit(-1);
	}

	host = argv[1];
	portnum = argv[2];

	lib_init();

	for (i = 3; i < argc; i++) {
		if (strcmp("tls-1.2", argv[i]) == 0) {
			method = TLSv1_2_client_method();
		} else if (strcmp("tls-1.1", argv[i]) == 0) {
			method = TLSv1_1_client_method();
		} else if (strcmp("tls-1.0", argv[i]) == 0) {
			method = TLSv1_client_method();
		} else if (strcmp("ssl-3.0", argv[i]) == 0) {
			method = SSLv3_client_method();
		} else if (strcmp("bench-send", argv[i]) == 0) {
			bench_send = atoi(argv[++i]);
		} else if (strcmp("bench-recv", argv[i]) == 0) {
			bench_recv = atoi(argv[++i]);
		} else {
			printf("warning: unknown option: \"%s\"\n", argv[i]);
		}
	}

	ctx = client_init(method, cipher_choice);

	client_fd = connect_socket(host, atoi(portnum));

	printf("[status] connected. handshaking\n");

	SSL *ssl;
	ssl = SSL_new(ctx);
	SSL_set_fd(ssl, client_fd);

	if (bench_send > 0 || bench_recv > 0)
		benchmark(ssl, bench_send, bench_recv);
	else
		process(ssl);
	close(client_fd);
	SSL_CTX_free(ctx);
	return 0;
}