int fserve_client_create(client_t *httpclient, char *path)
{
    fserve_t *client = calloc(1, sizeof(fserve_t));
    int bytes;
    int client_limit;
    ice_config_t *config = config_get_config();

    client_limit = config->client_limit;
    config_release_config();

    client->file = fopen(path, "rb");
    if(!client->file) {
        client_send_404(httpclient, "File not readable");
        return -1;
    }

    client->client = httpclient;
    client->offset = 0;
    client->datasize = 0;
    client->ready = 0;
    client->buf = malloc(BUFSIZE);

    global_lock();
    if(global.clients >= client_limit) {
        httpclient->respcode = 504;
        bytes = sock_write(httpclient->con->sock,
                "HTTP/1.0 504 Server Full\r\n"
                "Content-Type: text/html\r\n\r\n"
                "<b>Server is full, try again later.</b>\r\n");
        if(bytes > 0) httpclient->con->sent_bytes = bytes;
        fserve_client_destroy(client);
        global_unlock();
        return -1;
    }
    global.clients++;
    global_unlock();

    httpclient->respcode = 200;
    bytes = sock_write(httpclient->con->sock,
            "HTTP/1.0 200 OK\r\n"
            "Content-Type: %s\r\n\r\n",
            fserve_content_type(path));
    if(bytes > 0) httpclient->con->sent_bytes = bytes;

    sock_set_blocking(client->client->con->sock, SOCK_NONBLOCK);
    sock_set_nodelay(client->client->con->sock);

    thread_mutex_lock (&pending_lock);
    client->next = (fserve_t *)pending_list;
    pending_list = client;
    thread_mutex_unlock (&pending_lock);

    return 0;
}

uint32_t proto_send(uint16_t header, sock_t* s)
{
  prefix_t prefix;

  prefix.header = (header | MAGIC);
  prefix.length = 0;

  sock_write(s, &prefix, sizeof(prefix.header));
  sock_write(s, &prefix.length, sizeof(prefix.length));

  return sock_flush(s);
}

int GUIAPI ServerSendReply (int clifd, const void* reply, int len)
{
    MSG reply_msg = {HWND_INVALID, 0};
    if (!mgIsServer)
        return SOCKERR_IO;

    /* send a reply message to indicate this is a reply of request */
    if (sock_write (clifd, &reply_msg, sizeof (MSG)) < 0)
        return SOCKERR_IO;

    if (sock_write (clifd, reply, len) < 0)
        return SOCKERR_IO;
    return SOCKERR_OK;
}

void main()
{
	int bytes_read;
	char	buffer[100]; 	/* Currently (DC 7.30), printf() has max 127 bytes it can output. */
	tcp_Socket socket;
	
	sock_init();
	
	while(1) {
		tcp_listen(&socket,PORT,0,0,NULL,0);

		printf("Waiting for connection...\n");
		while(!sock_established(&socket) && sock_bytesready(&socket)==-1)
			tcp_tick(NULL);

		printf("Connection received...\n");

		do {
			bytes_read=sock_fastread(&socket,buffer,sizeof(buffer)-1);

			if(bytes_read>0) {
				buffer[bytes_read]=0;
				printf("%s",buffer);
				sock_write(&socket,buffer,bytes_read);
			}
		} while(tcp_tick(&socket));

		printf("Connection closed...\n");
	}
}

int socket_write(Socket_T S, void *b, int size) {
  
  int n= 0;
  void *p= b;
  
  ASSERT(S);
  
  /* Clear any extra data read from the server */
  socket_reset(S);

  while(size > 0) {
    
    if(S->ssl) {
      n= send_ssl_socket(S->ssl, p, size, S->timeout);
    } else {
      if(S->type==SOCK_DGRAM)
        n= udp_write(S->socket,  p, size, S->timeout);
      else
        n= sock_write(S->socket,  p, size, S->timeout);
    }
    
    if(n <= 0) break;
    p+= n;
    size-= n;
    
  }
  
  if(n < 0) {
    /* No write or a partial write is an error */
    return -1;
  }
  
  return  (int)(p - b);
  
}

static void exec_lua_cb( Widget w, void *u, void *c )
{
    TRACE(1,"arg: %s", (char*) u);
    int sln = CWNET.sln;
    int fd = sln_get_fd(sln );
    if( fd < 0 ) {
	WARN("no connections to lua server");
	return;
    }

    char *filename = (char*) u;
    FILE *fp = fopen( filename, "r" );
    if(!fp) WARN("faild to open %s", filename );
    else {

	int buf = m_create(1000,1); 
	int ch; int crc=0;
	/* write program header to slop buffer */
        crc = slop_encode_str(buf,crc, "PUT:");

	

	
	/* write program to slop buffer, -1 will finalize the packet */
	do {
	    ch=fgetc(fp);
	    crc = slop_encode(buf,crc, ch);
	} while( ch >= 0);
	fclose(fp);
	sock_write(fd,buf); 
	
    }
    
}

void
send_option(int type, int opt)
{
    int ret;
    int size;
    unsigned char *obp;

    obp = &Comobuf[0];

    *obp++ = IAC;
    *obp++ = type;
    *obp++ = opt;

    size = 3;
    obp = &Comobuf[0];

    if (Debug > 2) {
	sysmessage(MSG_DEBUG, "Sock_write, 3 bytes: %02X %02X %02X\n",
		   Comobuf[0], Comobuf[1], Comobuf[2]);
    }

    while (size) {
	if ((ret = sock_write(obp, size)) == -1) {
	    SET_EVENT(EV_RN, EV_RNHANG, 0, 0);
	    break;
	}
	else if (ret != size) {
	    sysmessage(MSG_NOTICE,
		       "Partial write in send_option: %d/%d\n", ret, size);
	    sysdelay(ROOM_DELAY);	/* Wait for room */
	}
	size -= ret;
	obp += ret;
    }
}

static void command_buildm3u(client_t *client, source_t *source,
    int response)
{
    char *username = NULL;
    char *password = NULL;
    char *host = NULL;
    int port = 0;
    ice_config_t *config;

    COMMAND_REQUIRE(client, "username", username);
    COMMAND_REQUIRE(client, "password", password);

    config = config_get_config();
    host = strdup(config->hostname);
    port = config->port;
    config_release_config();

    client->respcode = 200;
    sock_write(client->con->sock,
        "HTTP/1.0 200 OK\r\n"
        "Content-Type: audio/x-mpegurl\r\n"
        "Content-Disposition = attachment; filename=listen.m3u\r\n\r\n" 
        "http://%s:%[email protected]%s:%d%s\r\n",
        username,
        password,
        host,
        port,
        source->mount
    );

    free(host);
    client_destroy(client);
}

int SocketWrite(SocketRef const socket, uv_buf_t const *const buf) {
	if(!socket) return UV_EINVAL;
	assert(socket->wr->len < WRITE_BUFFER);
	int rc;
	if(buf->len > WRITE_BUFFER) {
		rc = SocketFlush(socket, false);
		if(rc < 0) return rc;
		rc = sock_write(socket, buf);
		if(rc < 0) return rc;
		return 0;
	}
	if(!socket->wr->base) {
		socket->wr->base = malloc(WRITE_BUFFER);
		if(!socket->wr->base) return UV_ENOMEM;
	}
	size_t const used = MIN(WRITE_BUFFER - socket->wr->len, buf->len);
	size_t const rest = buf->len - used;
	memcpy(socket->wr->base + socket->wr->len, buf->base, used);
	socket->wr->len += used;
	if(WRITE_BUFFER == socket->wr->len) {
		rc = SocketFlush(socket, true);
		if(rc < 0) return rc;
		memcpy(socket->wr->base, buf->base + used, rest);
		socket->wr->len = rest;
		assert(rest < WRITE_BUFFER);
	}
	return 0;
}

int32_t _connector_write(struct handler_t* h)
{
    char* buffer;
    int32_t nwrite, res;
    connector_t* con = (connector_t*)h;

    nwrite = connbuffer_read_len(con->write_buf);
    if (nwrite <= 0) return 0;
    buffer = connbuffer_read_buffer(con->write_buf);
    res = sock_write(con->h.fd, buffer, nwrite);
    if (res < 0) {
        // can't write now
        if (ERR_EAGAIN == ERRNO || ERR_EWOULDBLOCK == ERRNO || ERR_EINTR == ERRNO) {
            return 0;
        } else {
            printf("write %d errno=%d\n", con->h.fd, ERRNO);
            return -1;
        }
    } else if (0 == res) {
        return -1;
    } else {
        connbuffer_read_nocopy(con->write_buf, res);
        if (res == nwrite) {
            reactor_modify(con->r, &con->h, EVENT_IN);
        }
    }
    return 0;
}

static int netchar_open(struct inode* inodp, struct file* fp)
{
	int                ret;
	struct fop_request req;
	struct fop_reply   rep;

	memset(&req, 0, sizeof(req));
	memset(&rep, 0, sizeof(rep));

	_PKI("open....");

	req.call  = FOP_OPEN;
	req.flags = fp->f_flags;
	req.mode  = fp->f_mode;

	ret = sock_write(nc_socket, &req, sizeof(req));

	_PKI("sendmsg: %i", ret);

	ret = sock_read(nc_socket, &rep, sizeof(rep));

	_PKI("recvmsg: %i", ret);
	_PKI("open returning %i", rep.open);

	return rep.open;
}

/* Always in ASCII mode */
int sock_puts( SOCKET s, const char *pszText )
{
	sock_flushbuffer( s );
	int nBufLen = sock_write( s, pszText );
	send( s, "\r\n", 2, 0 );
    //printf("\n *DEBUG* sock_puts=[%s]", pszText );
	return nBufLen + 2;
}

/*
 * Send the response to the remote machine
 */
void SendMessage(tcp_Socket *tcpSock, unsigned key, char* messages[])
{

    sock_write(tcpSock, messages[key], strlen(messages[key])+1);
    sock_close(tcpSock);
    while (tcp_tick(tcpSock) != 0);
    return;
}

static int sock_puts(BIO *bp, const char *str)
{
    int n, ret;

    n = strlen(str);
    ret = sock_write(bp, str, n);
    return (ret);
}

void client_send_403(client_t *client) {
    int bytes = sock_write(client->con->sock, 
            "HTTP/1.0 403 Forbidden\r\n"
            "\r\n"
            "Access restricted.\r\n");
    if(bytes > 0) client->con->sent_bytes = bytes;
    client->respcode = 403;
    client_destroy(client);
}

static int _send_event_to_client(stats_event_t *event, connection_t *con)
{
    int ret;

    /* send data to the client!!!! */
    ret = sock_write(con->sock, "EVENT %s %s %s\n", (event->source != NULL) ? event->source : "global", event->name, event->value ? event->value : "null");

    return (ret == -1) ? 0 : 1;
}

int SocketFlush(SocketRef const socket, bool const more) {
	if(!socket) return UV_EINVAL;
	if(0 == socket->wr->len) return 0;
	assert(socket->wr->base);
	int rc = sock_write(socket, socket->wr);
	if(!more) FREE(&socket->wr->base);
	socket->wr->len = 0;
	return rc;
}

/* 
 * Write a printf() style and newline terminated message to the socket 
 * Return 1 if all bytes where successfully written, and 0 if not.
 * Assert Class: 2
 * Potential problems: Will truncate the string if longer than BUFSIZE bytes.
 */
int sock_write_line(SOCKET sockfd, const char *fmt, ...)
{
	char buff[BUFSIZE];
	va_list ap;

	va_start(ap, fmt);
	vsnprintf(buff, BUFSIZE, fmt, ap);
	return sock_write(sockfd, "%s\r\n", buff);
}

static ssize_t netchar_write(struct file* fp, const char *buffer,
                             size_t length, loff_t* offset)
{
	int                ret;
	struct fop_request req;
	struct fop_reply   rep;
	void*        payload = NULL;

	memset(&req, 0, sizeof(req));
	memset(&rep, 0, sizeof(rep));

	_PKI("write...");

	req.call  = FOP_WRITE;
	req.count = length;

	ret = sock_write(nc_socket, &req, sizeof(req));

	_PKI("sendmsg: %i", ret);

	payload = kmalloc(length, GFP_KERNEL);
	if(payload == NULL){
		_PKA("Write Error: kmalloc returned NULL");
		return 0;
	}
	
	ret = copy_from_user(payload, buffer, length);

	_PKI("payload copy returned: %i", ret);

	ret = sock_write(nc_socket, payload, length);

	kfree(payload);
	payload = NULL;

	_PKI("write data: %i", ret);
	
	ret = sock_read(nc_socket, &rep, sizeof(rep));

	_PKI("recvmsg: %i", ret);
	_PKI("`write returning %zi", rep.write);

	return rep.read;
}

int
comport_command(int command, int arg)
{
    int size;
    int ret;
    unsigned char *obp;

    if (Nvt.comport->support == FALSE) {
	CLR_CMD_ACTIVE(command);	/* Synchronous operation */
	SET_EVENT(EV_RN, EV_RNCMDOK, 0, 0);
	return (0);
    }

    obp = &Comobuf[0];

    *obp++ = IAC;
    *obp++ = SB;
    *obp++ = NVT_COM_PORT_OPTION;
    *obp++ = (unsigned char) command;
    switch (command) {
    case USR_COM_SET_BAUDRATE:
	SET_VALUE_4(obp, arg);
	obp += 4;
	break;
    default:
	SET_VALUE_1(obp, arg);
	obp += 1;
	break;
    }
    *obp++ = IAC;
    *obp++ = SE;

    size = (int) (obp - &Comobuf[0]);
    obp = &Comobuf[0];

    if (Debug > 2) {
	sysmessage(MSG_DEBUG,
		   "Sock_write, %d bytes: %02X %02X %02X %02X %02X %02X %02X %02X\n",
		   size, Comobuf[0], Comobuf[1], Comobuf[2], Comobuf[3],
		   Comobuf[4], Comobuf[5], Comobuf[6], Comobuf[7]);
    }
    while (size) {
	if ((ret = sock_write(obp, size)) == -1) {
	    SET_EVENT(EV_RN, EV_RNHANG, 0, 0);
	    return (-1);
	}
	else if (ret != size) {
	    sysmessage(MSG_NOTICE,
		       "Partial write in send_comport: %d/%d\n", ret, size);
	    sysdelay(ROOM_DELAY);	/* Wait for room */
	}
	size -= ret;
	obp += ret;
    }
    return (0);
}