[Destro-]

socket_recv_t()

It does not support a binary transfer (null byte)?

@EDIT
suggestions:
- Add the "iThreadHandle" param on callbacks or a array to pass custom data (if you do this, you could remove "iThreadState" and not implement "iThreadHandle")
- Remove param "protocol", only support TCP.
- iRecvDataLen is bytes received
- Check callback valid public fuction
- Support null bytes for recv

@EDIT2
win2008:
50% CPU usage on STATE_READ

code:

Spoiler

PHP Code:

#include <amxmodx>
#include <sockets>

new const upload_file[] = "test.txt"

new const upload_host[] = "localhost"
new const upload_script[] = "/screenshot/upload.php"

new g_SockThread

public plugin_init()
{
    register_plugin("Test Upload", "1.0", "Destro")
    
    set_task(3.0, "start_upload")
}

public start_upload()
{
    g_SockThread = socket_create_t()
    
    if((socket_open_t(g_SockThread, upload_host, 80, SOCKET_TCP, "open_socket")) < 0 )
    {
        server_print("ERROR: Could not open Socket.")
        return
    }
    
    server_print("Trying to open connection...")
}

public open_socket(thread_state, result)
{
    if(result < 0)
    {
        server_print("ERROR: Could not open Socket. Error[%d] : %d", result, socket_get_last_error_t(g_SockThread))
    }
    else
    {        
        new fp = fopen(upload_file, "rb")
        if(!fp)
        {
            server_print("ERROR: Coulds not open upload File [%s]", upload_file)
            return
        }
        
        new buff[2048], data[1800], packet_size, len/*, fsize*/
        
        /*fseek(fp, 0, SEEK_END)
        new fsize = ftell(fp)
        fseek(fp, 0, SEEK_SET)*/
        
        len = copy(data, charsmax(data),
        "--642865735weasdasdwe4285675865^r^nContent-Disposition: form-data; name=^"file^"; filename=^"asd^"^r^n^r^n")
        
        len += fread_blocks(fp, data[len], charsmax(data) - len - 50, BLOCK_CHAR)
        
        len += copy(data[len], charsmax(data) - len, "^r^n--642865735weasdasdwe4285675865--^r^n")
        
        
        packet_size = formatex(buff, charsmax(buff),
        "POST %s HTTP/1.1^nHost: %s^nContent-Type: multipart/form-data; boundary=642865735weasdasdwe4285675865^r^nContent-Length: %d^r^n^r^n",
        upload_script, upload_host, len)
        
        memcpy(data, len, buff[packet_size], charsmax(buff))
        copy(buff[packet_size], charsmax(buff) - packet_size, data)
        
        packet_size += len
        
        new fp_write = fopen("addons/amxmodx/logs/http_send.log", "wb")
        if(fp_write)
        {
            fwrite_blocks(fp_write, buff, packet_size, BLOCK_CHAR)
            fclose(fp_write)
        }
        
        if((socket_send_t(g_SockThread, buff, packet_size, "send_socket")) < 0 )
        {
            server_print("ERROR: Could not Send data.")
        }
    }
}

memcpy(const input[], size, output[], maxsize)
{
    for(new i; i < size && i < maxsize; i++ )
    {
        output[i] = input[i]
    }
}

public send_socket(thread_state, result)
{
    if(result < 0)
    {
        server_print("ERROR: Error Sending Data. Error[%d] : %d", result, socket_get_last_error_t(g_SockThread))
    }
    else
    {
        server_print("Socket Opened. Data Sent. Trying to receive Data..." )
        
        if((socket_recv_t(g_SockThread, "recv_socket", 128)) < 0)
        {
            server_print("ERROR: Could receive data.")
        }
    }
}

// 50% CPU Usage (but still works)
public recv_socket(thread_state, result, data[], datalen)
{
    if(result == 0)
    {
        server_print("Connection gracefully closed.")
        socket_close_t(g_SockThread, "close_socket")
    }
    else if(result < 0)
    {
        server_print("ERROR: Error while receiveing data. Error[%d] : %d", result, socket_get_last_error_t(g_SockThread))
        socket_close_t(g_SockThread, "close_socket")
    }
    else
    {

        new fp_write = fopen("addons/amxmodx/logs/http_recv.htm", "a")
        if(fp_write)
        {
            fputs(fp_write, data)
            fclose(fp_write)
        }
        
        server_print("Successfully Received: size[%d]", datalen)
    }
}

public close_socket(thread_state, result)
{
    if(result == 0)
    {
        server_print("Socket Closed. Destroying Thread.")
        socket_destroy_t(g_SockThread)
    }
    else
    {
        server_print("Error Closing socket.  Errno : %d", socket_get_last_error_t(g_SockThread))
    }
} 


@EDIT3
I haven't thought before, but threads are totally unnecessary, you can use non-blocking mode.

@EDIT4
Really I needed something functional now xd.

Github:
Github / Destro- / amxx / sockets_async

Last version

Spoiler

I'm doing the last tests on windows, later tests linux.

PHP Code:

#if defined _sockets_async_included
    #endinput
#endif
#define _sockets_async_included

#pragma reqlib sockets_async

enum SOCKET: {}


enum {
    SOCK_TYPE_UDP=0,
    SOCK_TYPE_TCP,
    SOCK_TYPE_CHILD // Son los nuevos sockets que se crean al aceptar una conexion TCP
}


native SOCKET:socket_create(type, customID)

native socket_close(SOCKET:socket)
native socket_bind(SOCKET:socket, const local_ip[]="", local_port)

native socket_get_custom(SOCKET:socket)
native socket_set_custom(SOCKET:socket, customID)

// TCP
native socket_connect(SOCKET:socket, const hostname[], port)
native socket_send(SOCKET:socket, const data[], sendsize=0)
native socket_recv(SOCKET:socket, data[], maxlen)

// UDP
native socket_sendto(SOCKET:socket, const ip[], port, const data[], sendsize=0)
native socket_recvfrom(SOCKET:socket, data[], maxlen, ip[], len, &port)

forward fw_sockConnected(SOCKET:socket, customID)
forward fw_sockClosed(SOCKET:socket, customID, error)
forward fw_sockAccepted(SOCKET:socket, customID, SOCKET:cl_sock, const cl_ip[], cl_port)
forward fw_sockReadable(SOCKET:socket, customID, type)