use Data::Dumper;

use Socket;

use Socket6;

use Digest::MD5 qw/md5_hex/;

	socket(SOCK, PF_INET, SOCK_STREAM, getprotobyname("tcp")) or die;

	setsockopt(SOCK, SOL_SOCKET, SO_REUSEADDR, pack("l", 1)) or die;

	bind(SOCK, sockaddr_in($PORT, INADDR_ANY)) or die;

	accept(S, SOCK) or die;

	# Shut down the socket with a RST.

	setsockopt(S, SOL_SOCKET, SO_LINGER, pack("II", 1, 0)) or die;

	close(S) or die;

local $xfail = 1;

server_client_test_tcp_ssl "Client closes socket write and keeps running after stdin EOF",

server_client_test_tcp_ssl "--send-only client closes socket write and stops running after stdin EOF",

  ac_fn_c_check_header_compile "$LINENO" "net/pfvar.h" "ac_cv_header_net_pfvar_h" "#include <sys/types.h>

#include <sys/socket.h>

#include <sys/types.h>

	    #include <sys/socket.h>

    # Unfortunately libsocket sometimes depends on libnsl and

    then

	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lsocket" >&5

$as_echo_n "checking for gethostbyname in -lsocket... " >&6; }

if ${ac_cv_lib_socket_gethostbyname+:} false; then :

  $as_echo_n "(cached) " >&6

  ac_check_lib_save_LIBS=$LIBS

LIBS="-lsocket -lnsl $LIBS"

if ac_fn_c_try_link "$LINENO"; then :

  ac_cv_lib_socket_gethostbyname=yes

else

--    - Implements a number of functions to handle communication over the

--        the socket.

  recv = function( self, socket )

    local status, data = socket:receive_buf(match.numbytes(12), true)

    local pos

    status, data = socket:receive_buf(match.numbytes(self.size), true)

  --- Converts the class to a string suitable to send over the socket

  --- Converts the class to a string suitable to send over the socket

  --- Converts the class to a string suitable to send over the socket

  --- Converts the class to a string suitable to send over the socket

-- ** Handles low-level packet sending, receiving, decoding and encoding.

-- ** Stores rpc programs info: socket, protocol, program name, id and version.

  -- @param port table

  -- @param timeout [optional] socket timeout in ms

  Connect = function(self, host, port, timeout)

    local status, err, socket

    timeout = timeout or stdnse.get_timeout(host, 10000)

    local new_socket = function(...)

      local socket = nmap.new_socket(...)

      socket:set_timeout(timeout)

      return socket

    end

          local resvport = math.random(1, 1024)

          socket = new_socket()

          status, err = socket:bind(nil, resvport)

--

--@param socket The socket to send the request through

--@return code_status True or false. If pattern was used, returns the result of code checking for the same result. If pattern was not used, is nil.

local function test(socket, req, pattern)

  local status, result = socket:send(req)

  if not status then

    socket:close()

  end

  status, result = socket:receive()

  if not status then

    socket:close()

function test_connect(host, port, proxyType, hostname)

  local status, socket = connectProxy(host, port, proxyType, hostname)

  if not status then

    return false, socket

-- options will necessarily affect every function):

-- * <code>timeout</code>: A timeout used for socket operations.

  -- keep-alive, or any server returns a response with Connection: close, read

  -- whatever's left on the socket (should be zero bytes).

-- Read one response from the socket <code>s</code> and return it after

-- @param options A table of other parameters. It may have any of these fields:

-- * <code>timeout</code>: A timeout used for socket operations.

  local socket, partial, opts = comm.tryssl(host, port, data, { timeout = options.timeout })

  if not socket then

    return http_error("Error creating socket.")

  end

    -- tryssl uses ssl if needed. sends the type 1 message.

    local socket, partial, opts = comm.tryssl(host, port, build_request(host, port, method, path, custom_options), { timeout = options.timeout })

-- BufferedWriter wraps the pack-functionality from bin, and buffers data internally

-- until flush is called. When flush is called, it either sends the data to the socket OR

-- returns the data, if no socket has been set.

--@usage:

-- local bWriter = BufferedWriter:new(socket)

-- local breader= BufferedReader:new(socket)

--

--

-- if bsocket:canRead(4) then -- Waits until four bytes can be read

--   local packetLength = bsocket:unpack('i') -- Read the four bytess

--   if bsocket:canRead(packetLength) then

--     -- ...continue reading packet values

BufferedWriter = {

  new = function(self, socket)

---

-- BufferedReader reads data from the supplied socket and contains functionality

#include <sys/types.h>

#include <sys/socket.h>

struct SysSocket

struct SysSocket *Sys_Net_CreateSocket(struct SysNetData *netdata, enum netaddrtype addrtype)

{

	struct SysSocket *s;

	{

		s->s = socket(domain, SOCK_DGRAM, 0);

void Sys_Net_DeleteSocket(struct SysNetData *netdata, struct SysSocket *socket)

{

	close(socket->s);

	free(socket);

struct SysSocket *Sys_Net_CreateSocket(struct SysNetData *netdata, enum netaddrtype addrtype)

{

	struct SysSocket *s;

	{

		s->s = socket(domain, SOCK_DGRAM, 0);

		{

			r = ioctlsocket(s->s, FIONBIO, &one);

	r = bind(socket->s, (struct sockaddr *)&addr, addrsize);

int Sys_Net_Send(struct SysNetData *netdata, struct SysSocket *socket, const void *data, int datalen, const struct netaddr *address)

		if (socket->domain == AF_INET)

		}

		else if (socket->domain == AF_INET6)

Most of the time you will be dealing with other APIs to do the real work:

[Mongoose](http://mongoosejs.com/docs/guide.html) for querying database, socket.io for sending and receiving messages over websockets,

### How do I use Socket.io with Hackathon Starter?

[Dan Stroot](https://github.com/dstroot) submitted an excellent [pull request](https://github.com/dstroot/hackathon-starter/commit/0a632def1ce8da446709d92812423d337c977d75) that adds a real-time dashboard with socket.io.

And as  much as I'd like to add it to the project, I think it violates one of the main

When I need to use socket.io, I **really** need it, but most of the time - I don't. But more

importantly, websockets support is still experimental on most hosting providers. As of October 2013,

Heroku supports websockets, but not until you opt-in by running this command:

```js

heroku labs:enable websockets -a myapp

And what if you are deploying to OpenShift? They do support websockets, but it is currently in a

preview state. So, for OpenShift you would need to change the socket.io connect URI to the following:

		descriptor_handler open_socket(int family, boost::system::error_code& ec)

		{

			const int socket_fd = ::socket(family, SOCK_DGRAM, 0);

			if (socket_fd < 0)

			return descriptor_handler(socket_fd);

		descriptor_handler socket = open_socket(AF_INET, ec);

		if (!socket.valid())

		descriptor_handler socket = open_socket(AF_INET, ec);

		if (!socket.valid())

import java.net.InetAddress;

import java.net.InetSocketAddress;

import java.net.ServerSocket;

import java.net.Socket;

import java.net.SocketException;

import java.net.SocketTimeoutException;

import java.net.URLDecoder;

    private static final void safeClose(Socket closeable) {

    private static final void safeClose(ServerSocket closeable) {

   /**

    * Creates an SSLSocketFactory for HTTPS.

    */

   public static SSLServerSocketFactory makeSSLSocketFactory(String keyAndTrustStoreClasspathPath, char[] passphrase) throws IOException {

import io

import socket

    appropriate service handler for the connection.

    @param sock: socket connection

    @type  sock: socket

    @param client_addr: client address

        Utility for reading the OK-byte/error-message header preceding each message.

        @param sock: socket connection. Will be read from if OK byte is

        false and error message needs to be read

        @type  sock: socket.socket

        Read service error from sock 

        @param sock: socket to read from

        @type  sock: socket

                    self.uri = master.lookupService(self.resolved_name)

                except socket.error:

import os

import socket

    try:

        reverse_ips = [host[4][0] for host in socket.getaddrinfo(hostname, 0, 0, 0, socket.SOL_TCP)]

    except socket.error:

        return False

        try:

            hostname = socket.gethostname()

    """

    Read in tcpros header off the socket \a sock using buffer \a b.

    """

    Write ROS handshake header header to socket sock

    :param sock: socket to write to (must be in blocking mode), ``socket.socket``

urlserver = {

    'socket'        : None,

    'http_scheme_display': ('http', 'display this scheme in shortened URLs'),

    'http_hostname'      : ('', 'force hostname/IP in bind of socket (empty value = auto-detect current hostname)'),

    scheme = urlserver_settings['http_scheme_display']

    hostname = urlserver_settings['http_hostname_display'] or urlserver_settings['http_hostname'] or socket.getfqdn()

        port = urlserver_settings['http_port_display']

    elif urlserver['socket']:

        port = urlserver['socket'].getsockname()[1]

    global urlserver

    if urlserver['socket']:

        weechat.prnt('', 'URL server listening on %s' % str(urlserver['socket'].getsockname()))

    else:

    global urlserver, urlserver_settings

    if urlserver['socket']:

use FileHandle;

use Socket;

        or die "** Failed packing $s_ip:$s_port\n";

    socket($waitmode_sock, PF_INET, SOCK_STREAM, getprotobyname('tcp'))

        or die "** Unable to open socket $s_ip:$s_port: $!\n";

    setsockopt($waitmode_sock, SOL_SOCKET, SO_REUSEADDR, 1)

        or die "** Unable to setsockopt(SO_REUSEADDR): $!\n";

    bind($waitmode_sock, $sin)

        or die "** Unable to bind socket ($s_port): $!\n";

          or die "** Failed packing $sint:$sport\n";

      socket($sock, PF_INET, SOCK_STREAM, getprotobyname('tcp'))

          or die "** Unable to open socket $sint:$sport\n";

      local $SIG{ALRM} =

          sub { die "** Timeout while connecting to socket $sint:$sport\n"; };

int flushbuffer (int socket, uschar *buffer)

  int retval, rsp;

  rsp = write(socket, buffer, Ustrlen(buffer));

    DEBUG(D_acl)

      debug_printf("DCC: Error writing buffer to socket: %s\n", strerror(errno));

    DEBUG(D_acl)

      debug_printf("DCC: Wrote buffer to socket:\n%s\n", buffer);

  /**************************************

   * Now creating the socket connection *

  /* If sockip contains an ip, we use a tcp socket, otherwise a UNIX socket */

    serv_addr_in.sin_port = htons(portnr);

    if ((sockfd = socket(AF_INET, SOCK_STREAM,0)) < 0){

      DEBUG(D_acl)

        connection.Project = mProjectID;

        connection.socket.write("RESPONSE_REGISTER_CONNECTION|DETAIL=API_KEY_INVALID;");

      else{

        connection.socket.write("FAILURE|DETAIL=NO_PROJECT_ID");

      console.log("FAILURE|DETAIL=API_KEY_INVALID;");

      connection.socket.write("FAILURE|DETAIL=API_KEY_INVALID;");

        console.log("INVALD KEY!");

        connection.socket.write("INVALID KEY!");

        ping: 0,

        ip: connection.socket.remoteAddress

      //socket.write(newController._id);

      console.log("TEST");

      console.log("FAILURE|DETAIL=API_KEY_INVALID;");

      socket.write("FAILURE|DETAIL=API_KEY_INVALID;");

  WebConsole(EventType.EVENT, EventDetail.COMMAND_HANDLER,

     "Server Attempting Registration", "Server Attempting Registration: SOCKET ID=" + connection.id );

import android.bluetooth.BluetoothDevice;

import android.bluetooth.BluetoothServerSocket;

import android.bluetooth.BluetoothSocket;

import android.content.BroadcastReceiver;

	// Name for the SDP record when creating server socket

		// Start the thread to listen on a BluetoothServerSocket

	 * 

	 * @param socket

	 *            The BluetoothSocket on which the connection was made

	 * @param device

	 */

	public synchronized void connected(BluetoothSocket socket,

		// Start the thread to manage the connection and perform transmissions

		mConnectedThread = new ConnectedThread(socket);

static void tds_put_params(TDSSOCKET * tds, TDSPARAMINFO * info, int flags);

static void tds7_put_query_params(TDSSOCKET * tds, const char *query, size_t query_len);

static void tds7_put_params_definition(TDSSOCKET * tds, const char *param_definition, size_t param_length);

static TDSRET tds_put_data_info(TDSSOCKET * tds, TDSCOLUMN * curcol, int flags);

static inline TDSRET tds_put_data(TDSSOCKET * tds, TDSCOLUMN * curcol);

static char *tds7_build_param_def_from_query(TDSSOCKET * tds, const char* converted_query, size_t converted_query_len, TDSPARAMINFO * params, size_t *out_len);

static char *tds7_build_param_def_from_params(TDSSOCKET * tds, const char* query, size_t query_len, TDSPARAMINFO * params, size_t *out_len);

static TDSRET tds_put_param_as_string(TDSSOCKET * tds, TDSPARAMINFO * params, int n);

static TDSRET tds_send_emulated_execute(TDSSOCKET * tds, const char *query, TDSPARAMINFO * params);

static TDSRET

tds_query_flush_packet(TDSSOCKET *tds)

static inline TDSRET

tds_put_data(TDSSOCKET * tds, TDSCOLUMN * curcol)