hyung-hwan/hio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

touched up socket related code more

Browse Source
This commit is contained in:
hyung-hwan
2016-03-30 16:31:56 +00:00
parent f0320a2ab7
commit 116b90fb74
11 changed files with 235 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
stio/lib/main.c
View File

@ -93,7 +93,7 @@ struct tcp_server_t
};
typedef struct tcp_server_t tcp_server_t;
static void tcp_on_disconnect (stio_dev_tcp_t* tcp)
static void tcp_on_disconnect (stio_dev_sck_t* tcp)
{
if (tcp->state & STIO_DEV_TCP_CONNECTING)
{
@ -116,7 +116,7 @@ static void tcp_on_disconnect (stio_dev_tcp_t* tcp)
printf ("TCP DISCONNECTED - THIS MUST NOT HAPPEN (%d - %x)\n", (int)tcp->sck, (unsigned int)tcp->state);
}
}
static int tcp_on_connect (stio_dev_tcp_t* tcp)
static int tcp_on_connect (stio_dev_sck_t* tcp)
{
if (tcp->state & STIO_DEV_TCP_CONNECTED)
@ -128,18 +128,17 @@ printf ("device connected to a remote server... .asdfjkasdfkljasdlfkjasdj...\n")
printf ("device accepted client device... .asdfjkasdfkljasdlfkjasdj...\n");
}
return stio_dev_tcp_write (tcp, "hello", 5, STIO_NULL);
return stio_dev_sck_write (tcp, "hello", 5, STIO_NULL, STIO_NULL);
}
static int tcp_on_write (stio_dev_tcp_t* tcp, stio_len_t wrlen, void* wrctx)
static int tcp_on_write (stio_dev_sck_t* tcp, stio_len_t wrlen, void* wrctx, const stio_sckadr_t* dstadr)
{
tcp_server_t* ts;
if (wrlen <= -1)
{
printf ("SEDING TIMED OUT...........\n");
stio_dev_tcp_halt(tcp);
stio_dev_sck_halt(tcp);
}
else
{
@ -147,21 +146,21 @@ else
printf (">>> SENT MESSAGE %d of length %ld\n", ts->tally, (long int)wrlen);
ts->tally++;
// if (ts->tally >= 2) stio_dev_tcp_halt (tcp);
// if (ts->tally >= 2) stio_dev_sck_halt (tcp);
printf ("ENABLING READING..............................\n");
stio_dev_tcp_read (tcp, 1);
stio_dev_sck_read (tcp, 1);
}
return 0;
}
static int tcp_on_read (stio_dev_tcp_t* tcp, const void* buf, stio_len_t len)
static int tcp_on_read (stio_dev_sck_t* tcp, const void* buf, stio_len_t len, const stio_sckadr_t* srcadr)
{
if (len <= 0)
{
printf ("STREAM DEVICE: EOF RECEIVED...\n");
/* no outstanding request. but EOF */
stio_dev_tcp_halt (tcp);
stio_dev_sck_halt (tcp);
return 0;
}
@ -172,19 +171,19 @@ int n;
static char a ='A';
char* xxx = malloc (1000000);
memset (xxx, a++ ,1000000);
//return stio_dev_tcp_write (tcp, "HELLO", 5, STIO_NULL);
//return stio_dev_sck_write (tcp, "HELLO", 5, STIO_NULL);
stio_inittime (&tmout, 1, 0);
n = stio_dev_tcp_timedwrite (tcp, xxx, 1000000, &tmout, STIO_NULL);
n = stio_dev_sck_timedwrite (tcp, xxx, 1000000, &tmout, STIO_NULL, STIO_NULL);
free (xxx);
if (n <= -1) return -1;
/* post the write finisher */
n = stio_dev_tcp_write (tcp, STIO_NULL, 0, STIO_NULL);
n = stio_dev_sck_write (tcp, STIO_NULL, 0, STIO_NULL, STIO_NULL);
if (n <= -1) return -1;
printf ("DISABLING READING..............................\n");
stio_dev_tcp_read (tcp, 0);
stio_dev_sck_read (tcp, 0);
return 0;
/* return 1; let the main loop to read more greedily without consulting the multiplexer */
@ -192,14 +191,15 @@ printf ("DISABLING READING..............................\n");
/* ========================================================================= */
static int arp_sck_on_read (stio_dev_sck_t* dev, const void* data, stio_len_t dlen, const stio_adr_t* srcadr)
static int arp_sck_on_read (stio_dev_sck_t* dev, const void* data, stio_len_t dlen, const stio_sckadr_t* srcadr)
{
stio_etharp_pkt_t* eap;
struct sockaddr_ll* sll = (struct sockaddr_ll*)srcadr;
if (dlen < STIO_SIZEOF(*eap)) return 0; /* drop */
eap = (stio_etharp_pkt_t*)data;
printf ("ARP OPCODE: %d", ntohs(eap->arphdr.opcode));
printf ("ARP ON IFINDEX %d OPCODE: %d", sll->sll_ifindex, ntohs(eap->arphdr.opcode));
printf (" SHA: %02X:%02X:%02X:%02X:%02X:%02X", eap->arppld.sha[0], eap->arppld.sha[1], eap->arppld.sha[2], eap->arppld.sha[3], eap->arppld.sha[4], eap->arppld.sha[5]);
printf (" SPA: %d.%d.%d.%d", eap->arppld.spa[0], eap->arppld.spa[1], eap->arppld.spa[2], eap->arppld.spa[3]);
printf (" THA: %02X:%02X:%02X:%02X:%02X:%02X", eap->arppld.tha[0], eap->arppld.tha[1], eap->arppld.tha[2], eap->arppld.tha[3], eap->arppld.tha[4], eap->arppld.tha[5]);
@ -227,14 +227,15 @@ int main ()
{
stio_t* stio;
stio_dev_udp_t* udp;
stio_dev_sck_t* sck;
stio_dev_tcp_t* tcp[2];
stio_dev_sck_t* tcp[2];
struct sockaddr_in sin;
struct sigaction sigact;
stio_dev_tcp_connect_t tcp_conn;
stio_dev_tcp_listen_t tcp_lstn;
stio_dev_tcp_make_t tcp_make;
stio_dev_sck_connect_t tcp_conn;
stio_dev_sck_listen_t tcp_lstn;
stio_dev_sck_bind_t tcp_bind;
stio_dev_sck_make_t tcp_make;
stio_dev_sck_make_t sck_make;
tcp_server_t* ts;
@ -268,13 +269,11 @@ int main ()
}
*/
memset (&sin, 0, STIO_SIZEOF(sin));
sin.sin_family = AF_INET;
memset (&tcp_make, 0, STIO_SIZEOF(&tcp_make));
memcpy (&tcp_make.addr, &sin, STIO_SIZEOF(sin));
tcp_make.type = STIO_DEV_SCK_TCP4;
tcp_make.on_write = tcp_on_write;
tcp_make.on_read = tcp_on_read;
tcp[0] = stio_dev_tcp_make (stio, STIO_SIZEOF(tcp_server_t), &tcp_make);
tcp[0] = stio_dev_sck_make (stio, STIO_SIZEOF(tcp_server_t), &tcp_make);
if (!tcp[0])
{
printf ("Cannot make tcp\n");
@ -287,7 +286,7 @@ int main ()
memset (&sin, 0, STIO_SIZEOF(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(9999);
inet_pton (sin.sin_family, "192.168.1.4", &sin.sin_addr);
inet_pton (sin.sin_family, "192.168.1.119", &sin.sin_addr);
//inet_pton (sin.sin_family, "127.0.0.1", &sin.sin_addr);
memset (&tcp_conn, 0, STIO_SIZEOF(tcp_conn));
@ -295,21 +294,17 @@ int main ()
tcp_conn.tmout.sec = 5;
tcp_conn.on_connect = tcp_on_connect;
tcp_conn.on_disconnect = tcp_on_disconnect;
if (stio_dev_tcp_connect (tcp[0], &tcp_conn) <= -1)
if (stio_dev_sck_connect (tcp[0], &tcp_conn) <= -1)
{
printf ("stio_dev_tcp_connect() failed....\n");
printf ("stio_dev_sck_connect() failed....\n");
goto oops;
}
memset (&sin, 0, STIO_SIZEOF(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(1234);
memset (&tcp_make, 0, STIO_SIZEOF(&tcp_make));
memcpy (&tcp_make.addr, &sin, STIO_SIZEOF(sin));
tcp_make.on_write = tcp_on_write;
tcp_make.on_read = tcp_on_read;
tcp[1] = stio_dev_tcp_make (stio, STIO_SIZEOF(tcp_server_t), &tcp_make);
tcp[1] = stio_dev_sck_make (stio, STIO_SIZEOF(tcp_server_t), &tcp_make);
if (!tcp[1])
{
printf ("Cannot make tcp\n");
@ -318,12 +313,23 @@ int main ()
ts = (tcp_server_t*)(tcp[1] + 1);
ts->tally = 0;
memset (&tcp_bind, 0, STIO_SIZEOF(tcp_bind));
//memcpy (&tcp_bind.addr, &sin, STIO_SIZEOF(sin));
((struct sockaddr_in*)&tcp_bind.addr)->sin_family = AF_INET;
((struct sockaddr_in*)&tcp_bind.addr)->sin_port = htons(1234);
if (stio_dev_sck_bind (tcp[1],&tcp_bind) <= -1)
{
printf ("stio_dev_sck_bind() failed....\n");
goto oops;
}
tcp_lstn.backlogs = 100;
tcp_lstn.on_connect = tcp_on_connect;
tcp_lstn.on_disconnect = tcp_on_disconnect;
if (stio_dev_tcp_listen (tcp[1], &tcp_lstn) <= -1)
if (stio_dev_sck_listen (tcp[1], &tcp_lstn) <= -1)
{
printf ("stio_dev_tcp_listen() failed....\n");
printf ("stio_dev_sck_listen() failed....\n");
goto oops;
}
@ -344,11 +350,8 @@ int main ()
{
stio_etharp_pkt_t etharp;
struct sockaddr_ll sll;
stio_adr_t adr;
memset (&sll, 0, sizeof(sll));
adr.ptr = &sll;
adr.len = sizeof(sll);
sll.sll_family = AF_PACKET;
// sll.sll_protocol = STIO_CONST_HTON16(STIO_ETHHDR_PROTO_ARP);
// sll.sll_hatype = STIO_CONST_HTON16(STIO_ARPHDR_HTYPE_ETH);
@ -359,7 +362,6 @@ int main ()
/* if unicast ... */
//sll.sll_pkttype = PACKET_OTHERHOST;
// sll.sll_pkttype = PACKET_BROADCAST;
memset (&etharp, 0, sizeof(etharp));
memcpy (etharp.ethhdr.source, "\xB8\x6B\x23\x9C\x10\x76", STIO_ETHADR_LEN);
@ -374,7 +376,7 @@ int main ()
memcpy (etharp.arppld.sha, "\xB8\x6B\x23\x9C\x10\x76", STIO_ETHADR_LEN);
if (stio_dev_sck_write (sck, &etharp, sizeof(etharp), NULL, &adr) <= -1)
if (stio_dev_sck_write (sck, &etharp, sizeof(etharp), NULL, &sll) <= -1)
//if (stio_dev_sck_write (sck, &etharp.arphdr, sizeof(etharp) - sizeof(etharp.ethhdr), NULL, &adr) <= -1)
{
printf ("CANNOT WRITE ARP...\n");

22
stio/lib/stio-arp.h
View File

@ -41,9 +41,31 @@
#define STIO_ETHADR_LEN 6
#define STIO_IP4ADR_LEN 4
#define STIO_IP6ADR_LEN 16
#pragma pack(push)
#pragma pack(1)
struct stio_ethadr_t
{
stio_uint8_t v[STIO_ETHADR_LEN];
};
typedef struct stio_ethadr_t stio_ethadr_t;
struct stio_ip4adr_t
{
stio_uint8_t v[STIO_IP4ADR_LEN];
};
typedef struct stio_ip4adr_t stio_ip4adr_t;
struct stio_ip6adr_t
{
stio_uint8_t v[STIO_IP6ADR_LEN];
};
typedef struct stio_ip6adr_t stio_ip6adr_t;
struct stio_ethhdr_t
{
stio_uint8_t dest[STIO_ETHADR_LEN];

4
stio/lib/stio-pro.c
View File

@ -205,13 +205,13 @@ printf ("PRO READY...%p\n", dev);
return 1; /* the device is ok. carry on reading or writing */
}
static int pro_on_read (stio_dev_t* dev, const void* data, stio_len_t len, const stio_adr_t* srcadr)
static int pro_on_read (stio_dev_t* dev, const void* data, stio_len_t len, const stio_devadr_t* srcadr)
{
stio_dev_pro_t* pro = (stio_dev_pro_t*)dev;
return pro->on_read (pro, data, len);
}
static int pro_on_write (stio_dev_t* dev, void* wrctx, const stio_adr_t* dstadr)
static int pro_on_write (stio_dev_t* dev, void* wrctx, const stio_devadr_t* dstadr)
{
stio_dev_pro_t* pro = (stio_dev_pro_t*)dev;
return pro->on_write (pro, wrctx);

152
stio/lib/stio-sck.c
View File

@ -32,8 +32,10 @@
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netpacket/packet.h>
/* ========================================================================= */
void stio_closeasyncsck (stio_t* stio, stio_sckhnd_t sck)
@ -92,24 +94,80 @@ int stio_getsckadrinfo (stio_t* stio, const stio_sckadr_t* addr, stio_scklen_t*
{
struct sockaddr* saddr = (struct sockaddr*)addr;
if (saddr->sa_family == AF_INET)
switch (saddr->sa_family)
{
if (len) *len = STIO_SIZEOF(struct sockaddr_in);
if (family) *family = AF_INET;
return 0;
}
else if (saddr->sa_family == AF_INET6)
{
if (len) *len = STIO_SIZEOF(struct sockaddr_in6);
if (family) *family = AF_INET6;
return 0;
case AF_INET:
if (len) *len = STIO_SIZEOF(struct sockaddr_in);
if (family) *family = AF_INET;
return 0;
case AF_INET6:
if (len) *len = STIO_SIZEOF(struct sockaddr_in6);
if (family) *family = AF_INET6;
return 0;
case AF_PACKET:
if (len) *len = STIO_SIZEOF(struct sockaddr_ll);
if (family) *family = AF_INET6;
return 0;
}
stio->errnum = STIO_EINVAL;
return -1;
}
#if 0
static void stio_initsckadrforip4 (stio_sckadr_t* sckadr, stio_uint16_t port, stio_ip4adr_t* ip4adr)
{
struct sockaddr_in* sin = (struct sockaddr_in*)sckadr;
STIO_MEMSET (sin, 0, STIO_SIZEOF(*sin));
sin->sin_family = AF_INET;
sin->sin_port = htons(port);
STIO_MEMSET (&sin->sin_addr, ip4adr, STIO_IP4ADR_LEN);
}
static void stio_initsckadrforip6 (stio_sckadr_t* sckadr, stio_uint16_t port, stio_ip6adr_t* ip6adr)
{
struct sockaddr_in6* sin = (struct sockaddr_in6*)sckadr;
/* TODO: include sin6_scope_id */
STIO_MEMSET (sin, 0, STIO_SIZEOF(*sin));
sin->sin6_family = AF_INET;
sin->sin6_port = htons(port);
STIO_MEMSET (&sin->sin_addr, ip6adr, STIO_IP6ADR_LEN);
}
stio void stio_intisckadrforeth (stio_sckadr_t* sckadr, int ifindex, stio_ethadr_t* ethadr)
{
struct sockaddr_ll* sll = (struct sockaddr_in*)sckadr;
STIO_MEMSET (sll, 0, STIO_SIZEOF(*sll));
sll->sll_family = AF_PACKET;
sll->sll_ifindex = ifindex;
sll->sll_halen = STIO_ETHADR_LEN;
STIO_MEMSET (sll->sll_addr, ethadr, STIO_ETHADR_LEN);
}
#endif
static stio_devadr_t* sckadr_to_devadr (stio_dev_sck_t* dev, const stio_sckadr_t* sckadr, stio_devadr_t* devadr)
{
if (sckadr)
{
stio_scklen_t len;
stio_getsckadrinfo (dev->stio, sckadr, &len, STIO_NULL);
devadr->ptr = (void*)sckadr;
devadr->len = len;
return devadr;
}
return STIO_NULL;
}
static STIO_INLINE stio_sckadr_t* devadr_to_sckadr (stio_dev_sck_t* dev, const stio_devadr_t* devadr, stio_sckadr_t* sckadr)
{
return (stio_sckadr_t*)devadr->ptr;
}
/* ========================================================================= */
#define IS_STATEFUL(sck) ((sck)->dev_capa & STIO_DEV_CAPA_STREAM)
@ -120,7 +178,6 @@ struct sck_type_map_t
int type;
int proto;
int extra_dev_capa;
int sck_capa;
};
static struct sck_type_map_t sck_type_map[] =
@ -131,7 +188,9 @@ static struct sck_type_map_t sck_type_map[] =
{ AF_INET6, SOCK_DGRAM, 0, 0 },
{ AF_PACKET, SOCK_RAW, STIO_CONST_HTON16(0x0806), 0 },
{ AF_PACKET, SOCK_DGRAM, STIO_CONST_HTON16(0x0806), 0 }
{ AF_PACKET, SOCK_DGRAM, STIO_CONST_HTON16(0x0806), 0 },
{ AF_INET, SOCK_RAW, IPPROTO_ICMP, 0, }
};
/* ======================================================================== */
@ -229,7 +288,7 @@ static stio_syshnd_t dev_sck_getsyshnd (stio_dev_t* dev)
return (stio_syshnd_t)rdev->sck;
}
static int dev_sck_read_stateful (stio_dev_t* dev, void* buf, stio_len_t* len, stio_adr_t* srcadr)
static int dev_sck_read_stateful (stio_dev_t* dev, void* buf, stio_len_t* len, stio_devadr_t* srcadr)
{
stio_dev_sck_t* tcp = (stio_dev_sck_t*)dev;
ssize_t x;
@ -247,14 +306,14 @@ static int dev_sck_read_stateful (stio_dev_t* dev, void* buf, stio_len_t* len, s
return 1;
}
static int dev_sck_read_stateless (stio_dev_t* dev, void* buf, stio_len_t* len, stio_adr_t* srcadr)
static int dev_sck_read_stateless (stio_dev_t* dev, void* buf, stio_len_t* len, stio_devadr_t* srcadr)
{
stio_dev_sck_t* rdev = (stio_dev_sck_t*)dev;
stio_scklen_t srcadrlen;
ssize_t x;
srcadrlen = srcadr->len;
x = recvfrom (rdev->sck, buf, *len, 0, srcadr->ptr, &srcadrlen);
srcadrlen = STIO_SIZEOF(rdev->peeradr);
x = recvfrom (rdev->sck, buf, *len, 0, (struct sockaddr*)&rdev->peeradr, &srcadrlen);
if (x <= -1)
{
if (errno == EINPROGRESS || errno == EWOULDBLOCK) return 0; /* no data available */
@ -263,13 +322,15 @@ static int dev_sck_read_stateless (stio_dev_t* dev, void* buf, stio_len_t* len,
return -1;
}
srcadr->ptr = &rdev->peeradr;
srcadr->len = srcadrlen;
*len = x;
return 1;
}
static int dev_sck_write_stateful (stio_dev_t* dev, const void* data, stio_len_t* len, const stio_adr_t* dstadr)
static int dev_sck_write_stateful (stio_dev_t* dev, const void* data, stio_len_t* len, const stio_devadr_t* dstadr)
{
stio_dev_sck_t* rdev = (stio_dev_sck_t*)dev;
ssize_t x;
@ -305,7 +366,7 @@ static int dev_sck_write_stateful (stio_dev_t* dev, const void* data, stio_len_t
return 1;
}
static int dev_sck_write_stateless (stio_dev_t* dev, const void* data, stio_len_t* len, const stio_adr_t* dstadr)
static int dev_sck_write_stateless (stio_dev_t* dev, const void* data, stio_len_t* len, const stio_devadr_t* dstadr)
{
stio_dev_sck_t* rdev = (stio_dev_sck_t*)dev;
ssize_t x;
@ -402,7 +463,7 @@ static int dev_sck_ioctl (stio_dev_t* dev, int cmd, void* arg)
}
rdev->state |= STIO_DEV_SCK_CONNECTING;
rdev->peer = conn->addr;
rdev->peeradr = conn->addr;
rdev->on_connect = conn->on_connect;
rdev->on_disconnect = conn->on_disconnect;
return 0;
@ -415,7 +476,7 @@ static int dev_sck_ioctl (stio_dev_t* dev, int cmd, void* arg)
/* connected immediately */
rdev->state |= STIO_DEV_SCK_CONNECTED;
rdev->peer = conn->addr;
rdev->peeradr = conn->addr;
rdev->on_connect = conn->on_connect;
rdev->on_disconnect = conn->on_disconnect;
return 0;
@ -616,7 +677,7 @@ static int dev_evcb_sck_ready_stateful (stio_dev_t* dev, int events)
clidev->dev_capa |= STIO_DEV_CAPA_IN | STIO_DEV_CAPA_OUT | STIO_DEV_CAPA_STREAM;
clidev->state |= STIO_DEV_SCK_ACCEPTED;
clidev->peer = peer;
clidev->peeradr = peer;
/*clidev->parent = sck;*/
/* inherit some event handlers from the parent.
@ -680,52 +741,63 @@ static int dev_evcb_sck_ready_stateless (stio_dev_t* dev, int events)
return 1; /* the device is ok. carry on reading or writing */
}
static int dev_evcb_sck_on_read (stio_dev_t* dev, const void* data, stio_len_t dlen, const stio_adr_t* adr)
static int dev_evcb_sck_on_read_stateful (stio_dev_t* dev, const void* data, stio_len_t dlen, const stio_devadr_t* srcadr)
{
stio_dev_sck_t* rdev = (stio_dev_sck_t*)dev;
return rdev->on_read (rdev, data, dlen, adr);
return rdev->on_read (rdev, data, dlen, STIO_NULL);
}
static int dev_evcb_sck_on_write (stio_dev_t* dev, stio_len_t wrlen, void* wrctx, const stio_adr_t* adr)
static int dev_evcb_sck_on_write_stateful (stio_dev_t* dev, stio_len_t wrlen, void* wrctx, const stio_devadr_t* dstadr)
{
stio_dev_sck_t* rdev = (stio_dev_sck_t*)dev;
return rdev->on_write (rdev, wrlen, wrctx);
return rdev->on_write (rdev, wrlen, wrctx, STIO_NULL);
}
static int dev_evcb_sck_on_read_stateless (stio_dev_t* dev, const void* data, stio_len_t dlen, const stio_devadr_t* srcadr)
{
stio_dev_sck_t* rdev = (stio_dev_sck_t*)dev;
return rdev->on_read (rdev, data, dlen, srcadr->ptr);
}
static int dev_evcb_sck_on_write_stateless (stio_dev_t* dev, stio_len_t wrlen, void* wrctx, const stio_devadr_t* dstadr)
{
stio_dev_sck_t* rdev = (stio_dev_sck_t*)dev;
return rdev->on_write (rdev, wrlen, wrctx, dstadr->ptr);
}
static stio_dev_evcb_t dev_evcb_sck_stateful =
{
dev_evcb_sck_ready_stateful,
dev_evcb_sck_on_read,
dev_evcb_sck_on_write
dev_evcb_sck_on_read_stateful,
dev_evcb_sck_on_write_stateful
};
static stio_dev_evcb_t dev_evcb_sck_stateless =
{
dev_evcb_sck_ready_stateless,
dev_evcb_sck_on_read,
dev_evcb_sck_on_write
dev_evcb_sck_on_read_stateless,
dev_evcb_sck_on_write_stateless
};
/* ========================================================================= */
stio_dev_sck_t* stio_dev_sck_make (stio_t* stio, stio_size_t xtnsize, const stio_dev_sck_make_t* mkinf)
stio_dev_sck_t* stio_dev_sck_make (stio_t* stio, stio_size_t xtnsize, const stio_dev_sck_make_t* info)
{
stio_dev_sck_t* rdev;
if (mkinf->type < 0 && mkinf->type >= STIO_COUNTOF(sck_type_map))
if (info->type < 0 && info->type >= STIO_COUNTOF(sck_type_map))
{
stio->errnum = STIO_EINVAL;
return STIO_NULL;
}
if (sck_type_map[mkinf->type].extra_dev_capa & STIO_DEV_CAPA_STREAM) /* can't use the IS_STATEFUL() macro yet */
if (sck_type_map[info->type].extra_dev_capa & STIO_DEV_CAPA_STREAM) /* can't use the IS_STATEFUL() macro yet */
{
rdev = (stio_dev_sck_t*)stio_makedev (stio, STIO_SIZEOF(stio_dev_sck_t) + xtnsize, &dev_mth_sck_stateful, &dev_evcb_sck_stateful, (void*)mkinf);
rdev = (stio_dev_sck_t*)stio_makedev (stio, STIO_SIZEOF(stio_dev_sck_t) + xtnsize, &dev_mth_sck_stateful, &dev_evcb_sck_stateful, (void*)info);
}
else
{
rdev = (stio_dev_sck_t*)stio_makedev (stio, STIO_SIZEOF(stio_dev_sck_t) + xtnsize, &dev_mth_sck_stateless, &dev_evcb_sck_stateless, (void*)mkinf);
rdev = (stio_dev_sck_t*)stio_makedev (stio, STIO_SIZEOF(stio_dev_sck_t) + xtnsize, &dev_mth_sck_stateless, &dev_evcb_sck_stateless, (void*)info);
}
return rdev;
@ -746,12 +818,14 @@ int stio_dev_sck_listen (stio_dev_sck_t* dev, stio_dev_sck_listen_t* info)
return stio_dev_ioctl ((stio_dev_t*)dev, STIO_DEV_SCK_LISTEN, info);
}
int stio_dev_sck_write (stio_dev_sck_t* dev, const void* data, stio_len_t dlen, void* wrctx, const stio_adr_t* dstadr)
int stio_dev_sck_write (stio_dev_sck_t* dev, const void* data, stio_len_t dlen, void* wrctx, const stio_sckadr_t* dstadr)
{
return stio_dev_write ((stio_dev_t*)dev, data, dlen, wrctx, dstadr);
stio_devadr_t devadr;
return stio_dev_write ((stio_dev_t*)dev, data, dlen, wrctx, sckadr_to_devadr(dev, dstadr, &devadr));
}
int stio_dev_sck_timedwrite (stio_dev_sck_t* dev, const void* data, stio_len_t dlen, const stio_ntime_t* tmout, void* wrctx, const stio_adr_t* dstadr)
int stio_dev_sck_timedwrite (stio_dev_sck_t* dev, const void* data, stio_len_t dlen, const stio_ntime_t* tmout, void* wrctx, const stio_sckadr_t* dstadr)
{
return stio_dev_write ((stio_dev_t*)dev, data, dlen, wrctx, dstadr);
stio_devadr_t devadr;
return stio_dev_timedwrite ((stio_dev_t*)dev, data, dlen, tmout, wrctx, sckadr_to_devadr(dev, dstadr, &devadr));
}

44
stio/lib/stio-sck.h
View File

@ -101,15 +101,16 @@ typedef enum stio_dev_sck_state_t stio_dev_sck_state_t;
typedef struct stio_dev_sck_t stio_dev_sck_t;
typedef int (*stio_dev_sck_on_read_t) (
stio_dev_sck_t* dev,
const void* data,
stio_len_t dlen,
const stio_adr_t* srcadr
stio_dev_sck_t* dev,
const void* data,
stio_len_t dlen,
const stio_sckadr_t* srcadr
);
typedef int (*stio_dev_sck_on_write_t) (
stio_dev_sck_t* dev,
stio_len_t wrlen,
void* wrctx
stio_dev_sck_t* dev,
stio_len_t wrlen,
void* wrctx,
const stio_sckadr_t* dstadr
);
typedef int (*stio_dev_sck_on_connect_t) (stio_dev_sck_t* dev);
@ -123,7 +124,13 @@ enum stio_dev_sck_type_t
STIO_DEV_SCK_UDP6,
STIO_DEV_SCK_ARP,
STIO_DEV_SCK_ARP_DGRAM
STIO_DEV_SCK_ARP_DGRAM,
STIO_DEV_SCK_ICMP4
#if 0
STIO_DEV_SCK_RAW, /* raw L2-level packet */
#endif
};
typedef enum stio_dev_sck_type_t stio_dev_sck_type_t;
@ -165,11 +172,9 @@ struct stio_dev_sck_accept_t
{
stio_syshnd_t sck;
/* TODO: add timeout */
stio_sckadr_t peer;
stio_sckadr_t peeradr;
};
struct stio_dev_sck_t
{
STIO_DEV_HEADERS;
@ -186,7 +191,16 @@ struct stio_dev_sck_t
stio_dev_sck_on_connect_t on_connect;
stio_dev_sck_on_disconnect_t on_disconnect;
stio_tmridx_t tmridx_connect;
stio_sckadr_t peer;
/* peer address for a stateful stream socket. valid if one of the
* followings is set in state:
* STIO_DEV_TCP_ACCEPTED
* STIO_DEV_TCP_CONNECTED
* STIO_DEV_TCP_CONNECTING
*
* also used as a placeholder to store source address for
* a stateless socket */
stio_sckadr_t peeradr;
};
#ifdef __cplusplus
@ -245,7 +259,7 @@ STIO_EXPORT int stio_dev_sck_write (
const void* data,
stio_len_t len,
void* wrctx,
const stio_adr_t* dstadr
const stio_sckadr_t* dstadr
);
STIO_EXPORT int stio_dev_sck_timedwrite (
@ -254,7 +268,7 @@ STIO_EXPORT int stio_dev_sck_timedwrite (
stio_len_t len,
const stio_ntime_t* tmout,
void* wrctx,
const stio_adr_t* dstadr
const stio_sckadr_t* dstadr
);
#if defined(STIO_HAVE_INLINE)
@ -271,7 +285,7 @@ static STIO_INLINE int stio_dev_sck_read (stio_dev_sck_t* sck, int enabled)
}
/*
static STIO_INLINE int stio_dev_sck_write (stio_dev_sck_t* sck, const void* data, stio_len_t len, void* wrctx, const stio_adr_t* dstadr)
static STIO_INLINE int stio_dev_sck_write (stio_dev_sck_t* sck, const void* data, stio_len_t len, void* wrctx, const stio_devadr_t* dstadr)
{
return stio_dev_write ((stio_dev_t*)sck, data, len, wrctx, STIO_NULL);
}

6
stio/lib/stio-tcp.c
View File

@ -264,7 +264,7 @@ static int tcp_ioctl (stio_dev_t* dev, int cmd, void* arg)
}
tcp->state |= STIO_DEV_TCP_CONNECTING;
tcp->peer = conn->addr;
tcp->peeradr = conn->addr;
tcp->on_connect = conn->on_connect;
tcp->on_disconnect = conn->on_disconnect;
return 0;
@ -277,7 +277,7 @@ static int tcp_ioctl (stio_dev_t* dev, int cmd, void* arg)
/* connected immediately */
tcp->state |= STIO_DEV_TCP_CONNECTED;
tcp->peer = conn->addr;
tcp->peeradr = conn->addr;
tcp->on_connect = conn->on_connect;
tcp->on_disconnect = conn->on_disconnect;
return 0;
@ -465,7 +465,7 @@ printf ("TCP READY...%p\n", dev);
clitcp->dev_capa |= STIO_DEV_CAPA_IN | STIO_DEV_CAPA_OUT | STIO_DEV_CAPA_STREAM;
clitcp->state |= STIO_DEV_TCP_ACCEPTED;
clitcp->peer = peer;
clitcp->peeradr = peer;
/*clitcp->parent = tcp;*/
/* inherit some event handlers from the parent.

4
stio/lib/stio-tcp.h
View File

@ -68,7 +68,7 @@ struct stio_dev_tcp_t
* STIO_DEV_TCP_ACCEPTED
* STIO_DEV_TCP_CONNECTED
* STIO_DEV_TCP_CONNECTING */
stio_sckadr_t peer;
stio_sckadr_t peeradr;
/** return 0 on succes, -1 on failure/
* called on a new tcp device for an accepted client or
@ -121,7 +121,7 @@ struct stio_dev_tcp_accept_t
{
stio_syshnd_t sck;
/* TODO: add timeout */
stio_sckadr_t peer;
stio_sckadr_t peeradr;
};
#ifdef __cplusplus

11
stio/lib/stio-udp.c
View File

@ -25,6 +25,7 @@
*/
#if 0
#include "stio-udp.h"
#include "stio-prv.h"
@ -82,7 +83,7 @@ static stio_syshnd_t udp_getsyshnd (stio_dev_t* dev)
return (stio_syshnd_t)udp->sck;
}
static int udp_read (stio_dev_t* dev, void* buf, stio_len_t* len, stio_adr_t* adr)
static int udp_read (stio_dev_t* dev, void* buf, stio_len_t* len, stio_devadr_t* adr)
{
stio_dev_udp_t* udp = (stio_dev_udp_t*)dev;
stio_scklen_t addrlen;
@ -90,8 +91,8 @@ static int udp_read (stio_dev_t* dev, void* buf, stio_len_t* len, stio_adr_t* ad
/* TODO: udp_read need source address ... have to extend the send callback to accept the source address */
printf ("UDP RECVFROM...\n");
addrlen = STIO_SIZEOF(udp->peer);
x = recvfrom (udp->sck, buf, *len, 0, (struct sockaddr*)&udp->peer, &addrlen);
addrlen = STIO_SIZEOF(udp->peeradr);
x = recvfrom (udp->sck, buf, *len, 0, (struct sockaddr*)&udp->peeradr, &addrlen);
if (x <= -1)
{
if (errno == EINPROGRESS || errno == EWOULDBLOCK) return 0; /* no data available */
@ -104,7 +105,7 @@ printf ("UDP RECVFROM...\n");
return 1;
}
static int udp_write (stio_dev_t* dev, const void* data, stio_len_t* len, const stio_adr_t* adr)
static int udp_write (stio_dev_t* dev, const void* data, stio_len_t* len, const stio_devadr_t* adr)
{
stio_dev_udp_t* udp = (stio_dev_udp_t*)udp;
ssize_t x;
@ -184,3 +185,5 @@ stio_dev_udp_t* stio_dev_udp_make (stio_t* stio, stio_size_t xtnsize, const stio
{
return (stio_dev_udp_t*)stio_makedev (stio, STIO_SIZEOF(stio_dev_udp_t) + xtnsize, &udp_mth, &udp_evcb, (void*)data);
}
#endif

4
stio/lib/stio-udp.h
View File

@ -74,12 +74,12 @@ static STIO_INLINE int stio_dev_udp_read (stio_dev_udp_t* udp, int enabled)
return stio_dev_read ((stio_dev_t*)udp, enabled);
}
static STIO_INLINE int stio_dev_udp_write (stio_dev_udp_t* udp, const void* data, stio_len_t len, void* wrctx, const stio_adr_t* dstadr)
static STIO_INLINE int stio_dev_udp_write (stio_dev_udp_t* udp, const void* data, stio_len_t len, void* wrctx, const stio_devadr_t* dstadr)
{
return stio_dev_write ((stio_dev_t*)udp, data, len, wrctx, dstadr);
}
static STIO_INLINE int stio_dev_udp_timedwrite (stio_dev_udp_t* udp, const void* data, stio_len_t len, const stio_ntime_t* tmout, void* wrctx, const stio_adr_t* dstadr)
static STIO_INLINE int stio_dev_udp_timedwrite (stio_dev_udp_t* udp, const void* data, stio_len_t len, const stio_ntime_t* tmout, void* wrctx, const stio_devadr_t* dstadr)
{
return stio_dev_timedwrite ((stio_dev_t*)udp, data, len, tmout, wrctx, dstadr);
}

8
stio/lib/stio.c
View File

@ -266,7 +266,7 @@ printf ("has urgent data...\n");
if (dev && stio->revs[i].events & EPOLLIN)
{
stio_adr_t srcadr;
stio_devadr_t srcadr;
stio_len_t len;
int x;
@ -750,7 +750,7 @@ static void on_write_timeout (stio_t* stio, const stio_ntime_t* now, stio_tmrjob
if (x <= -1) stio_dev_halt (dev);
}
static int __dev_write (stio_dev_t* dev, const void* data, stio_len_t len, const stio_ntime_t* tmout, void* wrctx, const stio_adr_t* dstadr)
static int __dev_write (stio_dev_t* dev, const void* data, stio_len_t len, const stio_ntime_t* tmout, void* wrctx, const stio_devadr_t* dstadr)
{
const stio_uint8_t* uptr;
stio_len_t urem, ulen;
@ -894,12 +894,12 @@ enqueue_data:
return 0; /* request pused to a write queue. */
}
int stio_dev_write (stio_dev_t* dev, const void* data, stio_len_t len, void* wrctx, const stio_adr_t* dstadr)
int stio_dev_write (stio_dev_t* dev, const void* data, stio_len_t len, void* wrctx, const stio_devadr_t* dstadr)
{
return __dev_write (dev, data, len, STIO_NULL, wrctx, dstadr);
}
int stio_dev_timedwrite (stio_dev_t* dev, const void* data, stio_len_t len, const stio_ntime_t* tmout, void* wrctx, const stio_adr_t* dstadr)
int stio_dev_timedwrite (stio_dev_t* dev, const void* data, stio_len_t len, const stio_ntime_t* tmout, void* wrctx, const stio_devadr_t* dstadr)
{
return __dev_write (dev, data, len, tmout, wrctx, dstadr);
}

18
stio/lib/stio.h
View File

@ -48,8 +48,8 @@ struct stio_ntime_t
#define STIO_SYSHND_INVALID (-1)
#endif
typedef struct stio_adr_t stio_adr_t;
struct stio_adr_t
typedef struct stio_devadr_t stio_devadr_t;
struct stio_devadr_t
{
int len;
void* ptr;
@ -143,10 +143,10 @@ struct stio_dev_mth_t
/* return -1 on failure, 0 if no data is availble, 1 otherwise.
* when returning 1, *len must be sent to the length of data read.
* if *len is set to 0, it's treated as EOF. */
int (*read) (stio_dev_t* dev, void* data, stio_len_t* len, stio_adr_t* srcadr);
int (*read) (stio_dev_t* dev, void* data, stio_len_t* len, stio_devadr_t* srcadr);
/* ------------------------------------------------------------------ */
int (*write) (stio_dev_t* dev, const void* data, stio_len_t* len, const stio_adr_t* dstadr);
int (*write) (stio_dev_t* dev, const void* data, stio_len_t* len, const stio_devadr_t* dstadr);
/* ------------------------------------------------------------------ */
int (*ioctl) (stio_dev_t* dev, int cmd, void* arg);
@ -163,13 +163,13 @@ struct stio_dev_evcb_t
/* return -1 on failure, 0 or 1 on success.
* when 0 is returned, the main loop stops the attempt to read more data.
* when 1 is returned, the main loop attempts to read more data without*/
int (*on_read) (stio_dev_t* dev, const void* data, stio_len_t len, const stio_adr_t* srcadr);
int (*on_read) (stio_dev_t* dev, const void* data, stio_len_t len, const stio_devadr_t* srcadr);
/* return -1 on failure, 0 on success.
* wrlen is the length of data written. it is the length of the originally
* posted writing request for a stream device. For a non stream device, it
* may be shorter than the originally posted length. */
int (*on_write) (stio_dev_t* dev, stio_len_t wrlen, void* wrctx, const stio_adr_t* dstadr);
int (*on_write) (stio_dev_t* dev, stio_len_t wrlen, void* wrctx, const stio_devadr_t* dstadr);
};
struct stio_wq_t
@ -184,7 +184,7 @@ struct stio_wq_t
stio_dev_t* dev; /* back-pointer to the device */
stio_tmridx_t tmridx;
stio_adr_t dstadr;
stio_devadr_t dstadr;
};
#define STIO_WQ_INIT(wq) ((wq)->next = (wq)->prev = (wq))
@ -368,7 +368,7 @@ STIO_EXPORT int stio_dev_write (
const void* data,
stio_len_t len,
void* wrctx,
const stio_adr_t* dstadr
const stio_devadr_t* dstadr
);
@ -378,7 +378,7 @@ STIO_EXPORT int stio_dev_timedwrite (
stio_len_t len,
const stio_ntime_t* tmout,
void* wrctx,
const stio_adr_t* dstadr
const stio_devadr_t* dstadr
);
STIO_EXPORT void stio_dev_halt (