/* Creates a new reliable protocol session, returns NULL on failure.
* Exactly one of c and ss should be NULL. (ss is NULL when called
* from rlib.c, while c is NULL when this function is called from
* rel_demux.) */
rel_t *
rel_create(conn_t *c, const struct sockaddr_storage *ss,
const struct config_common *cc) {
rel_t *r;
r = xmalloc(sizeof(*r));
memset(r, 0, sizeof(*r));
if (!c) { //create a connection if there is no connection
c = conn_create(r, ss);
if (!c) {
free(r);
return NULL;
}
}
r->c = c; //set up r's connection
r->next = rel_list;
r->prev = &rel_list;
if (rel_list)
rel_list->prev = &r->next;
rel_list = r;
/* Do any other initialization you need here */
initialize(r, cc->window);
return r;
}
struct connection *server_create(struct context *ctx, int fd)
{
struct connection *server = conn_create(ctx);
server->info = conn_info_create(ctx);
server->fd = fd;
server->ready = server_ready;
return server;
}
int bot_create(struct bot* b)
{
b->conn = (conn_t*)malloc(sizeof(conn_t));
b->conf = (conf_t*)malloc(sizeof(conf_t));
conn_create(b->conn);
config_create(b->conf);
return 0;
}
/* Creates a new reliable protocol session, returns NULL on failure.
* Exactly one of c and ss should be NULL. (ss is NULL when called
* from rlib.c, while c is NULL when this function is called from
* rel_demux.) */
rel_t *
rel_create (conn_t *c, const struct sockaddr_storage *ss,
const struct config_common *cc)
{
rel_t *r;
r = xmalloc (sizeof (*r));
memset (r, 0, sizeof (*r));
if (!c) {
c = conn_create (r, ss);
if (!c) {
free (r);
return NULL;
}
}
r->c = c;
r->next = rel_list;
r->prev = &rel_list;
if (rel_list)
rel_list->prev = &r->next;
rel_list = r;
/* Do any other initialization you need here */
if (ss != NULL) {
r->ss = xmalloc (sizeof (*r->ss));
memcpy(r->ss, ss, sizeof (*r->ss));
}
r->SEND_EOF = false;
r->RECV_EOF = false;
r->EOF_ACKED = false;
r->destroy_wait = 0;
r->window_size = cc->window;
r->SWS = cc->window;
r->LAR = 0;
r->LSS = 0;
r->RWS = cc->window;
r->LSR = 0;
r->LAS = r->RWS + r->LSR;
r->sendWindow = xmalloc(r->SWS * sizeof(packet_t));
r->recvWindow = xmalloc(r->RWS * sizeof(packet_t));
r->sendState = xmalloc(r->SWS * sizeof(int));
r->recvState = xmalloc(r->RWS * sizeof(int));
r->sendTimer = xmalloc(r->SWS * sizeof(int));
int i = 0;
for (i=0; i<r->SWS; i++) {
r->sendState[i] = 1;
r->sendTimer[i] = 0;
r->recvState[i] = 0;
}
return r;
}
rel_t *
rel_create (conn_t *c, const struct sockaddr_storage *ss,
const struct config_common *cc)
{
rel_t *r;
r = xmalloc (sizeof (*r));
memset (r, 0, sizeof (*r));
if (!c) {
c = conn_create (r, ss);
if (!c) {
free (r);
return NULL;
}
}
r->c = c;
rel_list = r;
r->config = cc;
r->beginTime.tv_sec = 0;
r->beginTime.tv_usec = 0;
r->seqLast = -1;
r->noMoreAck = 0;
r->seqLast = -1;
r->adWindows = 1;
r->receiverBuff = NULL;
r->seqCurr = -1;
r->recvBuffOffset = 0;
r->prevAck = 0;
r->cwndSize = 3;
r->outputEOF = 0;
r->seqOut = 1;
r->ssthresh = INT_MAX;
r->seqCurr = -1;
r->inputEOF = 0;
r->adWindows = 1;
r->pairEOFed = 0;
r->seqIn = 1;
r->recvWindows = (r->config->window);
r->dupAckCount = 0;
r->outputEOF = 0;
r->senderBuff = NULL;
r->outputEOF = 0;
r->rttTime.tv_usec = 0;
r->endTime.tv_usec = 0;
r->rtt = 0;
r->rttTime.tv_sec = 0;
r->helperTime.tv_sec = 0;
r->helperTime.tv_usec = 0;
return r;
}
/* Creates a new reliable protocol session, returns NULL on failure.
* Exactly one of c and ss should be NULL. (ss is NULL when called
* from rlib.c, while c is NULL when this function is called from
* rel_demux.) */
rel_t *
rel_create (conn_t *c, const struct sockaddr_storage *ss,
const struct config_common *cc)
{
rel_t *r;
r = xmalloc (sizeof (*r));
memset (r, 0, sizeof (*r));
if (!c) {
c = conn_create (r, ss);
if (!c) {
free (r);
return NULL;
}
}
r->c = c;
r->next = rel_list;
r->prev = &rel_list;
if (rel_list)
rel_list->prev = &r->next;
rel_list = r;
/* Do any other initialization you need here */
r->windowSize = cc->window;
r->timeout = cc->timeout;
r->sentListSize = 0;
r->recvListSize = 0;
r->sentPackets = malloc(sizeof(wrapper *) * r->windowSize);
r->recvPackets = malloc(sizeof(wrapper *) * r->windowSize);
int i;
for (i = 0; i < r->windowSize; i++) {
r->sentPackets[i] = malloc(sizeof(wrapper));
r->sentPackets[i]->packet = malloc(sizeof(packet_t));
r->sentPackets[i]->acked = 0;
r->recvPackets[i] = malloc(sizeof(wrapper));
r->recvPackets[i]->packet = malloc(sizeof(packet_t));
r->recvPackets[i]->acked = 0;
}
r->LAST_PACKET_ACKED = 0;
r->LAST_PACKET_SENT = 0;
r->NEXT_PACKET_EXPECTED = 1;
r->eofSent = 0;
r->eofRecv = 0;
return r;
}
KrClient * kr_open(const char * dev)
{
KrClient * client = (KrClient *)malloc(sizeof(KrClient));
KrMsg msg;
size_t len = strlen(dev);
client->dev = malloc(len + 1);
strcpy(client->dev, dev);
printf("Creating connection...\n");
conn_create(client);
printf("Opening db \"%s\"...\n", client->dev);
conn_send(client, KR_COMMAND_OPEN, client->dev, len + 1);
conn_wait_reply(client, &msg);
client->db_id = *(uint8_t*)msg.data;
conn_msg_done(&msg);
return client;
}
/* Creates a new reliable protocol session, returns NULL on failure.
* Exactly one of c and ss should be NULL. (ss is NULL when called
* from rlib.c, while c is NULL when this function is called from
* rel_demux.) */
rel_t *
rel_create (conn_t *c, const struct sockaddr_storage *ss,
const struct config_common *cc)
{
// printf("rel_create\n");
rel_t *r;
r = xmalloc (sizeof (*r));
memset (r, 0, sizeof (*r));
if (!c) {
c = conn_create (r, ss);
if (!c) {
free (r);
return NULL;
}
}
r->startTime = getCurrentTime();
r->endTime = 0;
r->c = c;
rel_list = r;
/* Do any other initialization you need here */
if(r->c->sender_receiver == RECEIVER) {
r->windowSize = cc->window;
}
else {
r->windowSize = 1;
}
r->ssThresh = cc->window;
r->slowStart = 1;
r->timeout = cc->timeout;
r->sentListSize = 0;
r->recvListSize = 0;
r->sentPackets = malloc(sizeof(wrapper *) * r->ssThresh);
r->recvPackets = malloc(sizeof(wrapper *) * r->ssThresh);
int i;
for (i = 0; i < r->ssThresh; i++) {
r->sentPackets[i] = malloc(sizeof(wrapper));
r->sentPackets[i]->packet = malloc(sizeof(packet_t));
r->sentPackets[i]->acked = 0;
r->recvPackets[i] = malloc(sizeof(wrapper));
r->recvPackets[i]->packet = malloc(sizeof(packet_t));
r->recvPackets[i]->acked = 0;
}
r->LAST_PACKET_ACKED = 0;
r->LAST_PACKET_SENT = 0;
r->NEXT_PACKET_EXPECTED = 1;
r->eofSent = 0;
r->eofRecv = 0;
// initialize w to 1?
r->w = 1;
if(r->c->sender_receiver == RECEIVER) {
rel_read(r);
}
return r;
}
struct wtpman *wtpman_create(int socklistindex, struct sockaddr *srcaddr, int dtlsmode)
{
struct sockaddr dbgaddr;
socklen_t dbgaddrl;
int sockfd, replyfd;
char sock_buf[SOCK_ADDR_BUFSIZE];
struct wtpman *wtpman;
wtpman = malloc(sizeof(struct wtpman));
if (!wtpman)
return 0;
memset(wtpman, 0, sizeof(struct wtpman));
if (socklist[socklistindex].type != SOCKLIST_UNICAST_SOCKET) {
int port = sock_getport(&socklist[socklistindex].addr);
replyfd = socklist_find_reply_socket(srcaddr, port);
if (replyfd == -1) {
cw_log(LOG_ERR, "Can't find reply socket for request from %s",
sock_addr2str(srcaddr,sock_buf));
free(wtpman);
return NULL;
}
} else {
replyfd = socklist[socklistindex].sockfd;
}
sockfd = replyfd; /*//socklist[socklistindex].reply_sockfd;*/
dbgaddrl = sizeof(dbgaddr);
getsockname(sockfd, &dbgaddr, &dbgaddrl);
cw_dbg(DBG_INFO, "Creating wtpman on socket %d, %s:%d", sockfd,
sock_addr2str(&dbgaddr,sock_buf), sock_getport(&dbgaddr));
wtpman->conn = conn_create(sockfd, srcaddr, 100);
wtpman->conn->role = CW_ROLE_AC;
wtpman->conn->data_sock = socklist[socklistindex].data_sockfd;
sock_copyaddr(&wtpman->conn->data_addr, (struct sockaddr *) &wtpman->conn->addr);
if (!wtpman->conn) {
wtpman_destroy(wtpman);
return NULL;
}
wtpman->conn->mods = conf_mods;
wtpman->conn->strict_capwap = conf_strict_capwap;
wtpman->conn->strict_hdr = conf_strict_headers;
/*
// wtpman->conn->radios = mbag_i_create();
// wtpman->conn->radios_upd = mbag_i_create();
// wtpman->conn->local = ac_config;
//wtpman->conn->capwap_mode=0; //CW_MODE_STD; //CISCO;
// wtpman->conn->capwap_mode = CW_MODE_CISCO;
//wtpman->conn->strict_capwap_hdr=0;
*/
wtpman->conn->local_cfg = cw_ktv_create();
wtpman->conn->global_cfg = actube_global_cfg;
wtpman->conn->local_cfg = actube_global_cfg;
/* when created caused by a packet in DTLS mode, we try
* to find out the modules to load, for detected connection
* from discovery request */
if (dtlsmode){
int rc;
struct cw_Mod *cmod, *bmod;
rc = discovery_cache_get(discovery_cache,srcaddr,&cmod,&bmod);
if (rc){
cw_dbg(DBG_INFO, "Initializing with mod %s %s",cmod->name,bmod->name);
wtpman->conn->msgset = cw_mod_get_msg_set(wtpman->conn,cmod,bmod);
wtpman->conn->detected=1;
cmod->setup_cfg(wtpman->conn);
}
}
return wtpman;
}
int main(void)
{
struct vlc_http_stream *s;
struct vlc_http_msg *m;
struct block_t *b;
/* Dummy */
conn_create();
conn_destroy();
/* Test rejected connection */
conn_create();
conn_shutdown(SHUT_RD);
s = stream_open();
assert(s == NULL);
conn_destroy();
/* Test rejected stream */
conn_create();
s = stream_open();
assert(s != NULL);
conn_shutdown(SHUT_WR);
m = vlc_http_stream_read_headers(s);
assert(m == NULL);
b = vlc_http_stream_read(s);
assert(b == NULL);
m = vlc_http_stream_read_headers(s);
assert(m == NULL);
b = vlc_http_stream_read(s);
assert(b == NULL);
m = vlc_http_msg_get_initial(s);
assert(m == NULL);
s = stream_open();
assert(s == NULL);
conn_destroy();
/* Test garbage */
conn_create();
s = stream_open();
assert(s != NULL);
conn_send("Go away!\r\n\r\n");
conn_shutdown(SHUT_WR);
m = vlc_http_stream_read_headers(s);
assert(m == NULL);
b = vlc_http_stream_read(s);
assert(b == NULL);
conn_destroy();
vlc_http_stream_close(s, false);
/* Test HTTP/1.0 stream */
conn_create();
s = stream_open();
assert(s != NULL);
conn_send("HTTP/1.0 200 OK\r\n\r\n");
m = vlc_http_msg_get_initial(s);
assert(m != NULL);
conn_send("Hello world!");
conn_shutdown(SHUT_WR);
b = vlc_http_msg_read(m);
assert(b != NULL);
assert(b->i_buffer == 12);
assert(!memcmp(b->p_buffer, "Hello world!", 12));
block_Release(b);
b = vlc_http_msg_read(m);
assert(b == NULL);
vlc_http_msg_destroy(m);
conn_destroy();
/* Test HTTP/1.1 with closed connection */
conn_create();
s = stream_open();
assert(s != NULL);
conn_send("HTTP/1.1 200 OK\r\nConnection: close\r\n\r\n");
m = vlc_http_msg_get_initial(s);
assert(m != NULL);
conn_send("Hello again!");
conn_shutdown(SHUT_WR);
b = vlc_http_msg_read(m);
assert(b != NULL);
assert(b->i_buffer == 12);
assert(!memcmp(b->p_buffer, "Hello again!", 12));
block_Release(b);
b = vlc_http_msg_read(m);
assert(b == NULL);
vlc_http_msg_destroy(m);
conn_destroy();
/* Test HTTP/1.1 with chunked transfer encoding */
conn_create();
s = stream_open();
assert(s != NULL);
conn_send("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n"
"Content-Length: 1000000\r\n\r\n"); /* length must be ignored */
m = vlc_http_msg_get_initial(s);
assert(m != NULL);
conn_send("C\r\nHello there!\r\n0\r\n\r\n");
b = vlc_http_msg_read(m);
assert(b != NULL);
assert(b->i_buffer == 12);
assert(!memcmp(b->p_buffer, "Hello there!", 12));
block_Release(b);
conn_destroy(); /* test connection release before closing stream */
b = vlc_http_msg_read(m);
assert(b == NULL);
vlc_http_msg_destroy(m);
/* Test HTTP/1.1 with content length */
conn_create();
s = stream_open();
assert(s != NULL);
conn_send("HTTP/1.1 200 OK\r\nContent-Length: 8\r\n\r\n");
m = vlc_http_msg_get_initial(s);
assert(m != NULL);
conn_send("Bye bye!");
b = vlc_http_msg_read(m);
assert(b != NULL);
assert(b->i_buffer == 8);
assert(!memcmp(b->p_buffer, "Bye bye!", 8));
block_Release(b);
b = vlc_http_msg_read(m);
assert(b == NULL);
vlc_http_msg_destroy(m);
conn_destroy();
return 0;
}
rel_t *
rel_create (conn_t *c, const struct sockaddr_storage *ss,
const struct config_common *cc)
{
assert((c != NULL && ss == NULL) || (c == NULL && ss != NULL));
assert(cc);
rel_t *r;
r = xmalloc (sizeof (*r));
memset (r, 0, sizeof (*r));
if (!c) {
c = conn_create (r, ss);
if (!c) {
free (r);
return NULL;
}
}
r->c = c;
r->next = rel_list;
r->prev = &rel_list;
if (rel_list)
rel_list->prev = &r->next;
rel_list = r;
/* Set the sockaddr_storage for this connection */
if (ss) memcpy(&r->ss,ss,sizeof(struct sockaddr_storage));
/* Save the configurations we'll need */
r->timeout = cc->timeout;
r->window = cc->window;
r->single_connection = cc->single_connection;
/* Create a buffer queue for sending and receiving, starting at
* index 1 */
r->send_bq = bq_new(SEND_BUFFER_INITIAL_SIZE, sizeof(send_bq_element_t));
bq_increase_head_seq_to(r->send_bq,1);
r->rec_bq = bq_new(cc->window, sizeof(packet_t));
bq_increase_head_seq_to(r->rec_bq,1);
/* Send an receive state */
r->seqno = 1;
r->ackno = 1;
/* Connection teardown state */
r->read_eof = 0;
r->printed_eof = 0;
/* Nagle state */
r->nagle_outstanding = 0;
return r;
}
static int sd_accept(t_addr const * curr_laddr, t_laddr_info const * laddr_info, int ssocket, int usocket)
{
char tempa[32];
int csocket;
struct sockaddr_in caddr;
psock_t_socklen caddr_len;
unsigned int raddr;
unsigned short rport;
if (!addr_get_addr_str(curr_laddr,tempa,sizeof(tempa)))
strcpy(tempa,"x.x.x.x:x");
/* accept the connection */
memset(&caddr,0,sizeof(caddr)); /* not sure if this is needed... modern systems are ok anyway */
caddr_len = sizeof(caddr);
if ((csocket = psock_accept(ssocket,(struct sockaddr *)&caddr,&caddr_len))<0)
{
/* BSD, POSIX error for aborted connections, SYSV often uses EAGAIN or EPROTO */
if (
#ifdef PSOCK_EWOULDBLOCK
psock_errno()==PSOCK_EWOULDBLOCK ||
#endif
#ifdef PSOCK_ECONNABORTED
psock_errno()==PSOCK_ECONNABORTED ||
#endif
#ifdef PSOCK_EPROTO
psock_errno()==PSOCK_EPROTO ||
#endif
0)
eventlog(eventlog_level_error,"sd_accept","client aborted connection on %s (psock_accept: %s)",tempa,strerror(psock_errno()));
else /* EAGAIN can mean out of resources _or_ connection aborted :( */
if (
#ifdef PSOCK_EINTR
psock_errno()!=PSOCK_EINTR &&
#endif
1)
eventlog(eventlog_level_error,"sd_accept","could not accept new connection on %s (psock_accept: %s)",tempa,strerror(psock_errno()));
return -1;
}
#ifdef HAVE_POLL
if (csocket>=BNETD_MAX_SOCKETS) /* This check is a bit too strict (csocket is probably
* greater than the number of connections) but this makes
* life easier later.
*/
{
eventlog(eventlog_level_error,"sd_accept","csocket is beyond range allowed by BNETD_MAX_SOCKETS for poll() (%d>=%d)",csocket,BNETD_MAX_SOCKETS);
psock_close(csocket);
return -1;
}
#else
# ifdef FD_SETSIZE
if (csocket>=FD_SETSIZE) /* fd_set size is determined at compile time */
{
eventlog(eventlog_level_error,"sd_accept","csocket is beyond range allowed by FD_SETSIZE for select() (%d>=%d)",csocket,FD_SETSIZE);
psock_close(csocket);
return -1;
}
# endif
#endif
if (ipbanlist_check(inet_ntoa(caddr.sin_addr))!=0)
{
eventlog(eventlog_level_info,"sd_accept","[%d] connection from banned address %s denied (closing connection)",csocket,inet_ntoa(caddr.sin_addr));
psock_close(csocket);
return -1;
}
eventlog(eventlog_level_info,"sd_accept","[%d] accepted connection from %s on %s",csocket,addr_num_to_addr_str(ntohl(caddr.sin_addr.s_addr),ntohs(caddr.sin_port)),tempa);
if (prefs_get_use_keepalive())
{
int val=1;
if (psock_setsockopt(csocket,PSOCK_SOL_SOCKET,PSOCK_SO_KEEPALIVE,&val,(psock_t_socklen)sizeof(val))<0)
eventlog(eventlog_level_error,"sd_accept","[%d] could not set socket option SO_KEEPALIVE (psock_setsockopt: %s)",csocket,strerror(psock_errno()));
/* not a fatal error */
}
{
struct sockaddr_in rsaddr;
psock_t_socklen rlen;
memset(&rsaddr,0,sizeof(rsaddr)); /* not sure if this is needed... modern systems are ok anyway */
rlen = sizeof(rsaddr);
if (psock_getsockname(csocket,(struct sockaddr *)&rsaddr,&rlen)<0)
{
eventlog(eventlog_level_error,"sd_accept","[%d] unable to determine real local port (psock_getsockname: %s)",csocket,strerror(psock_errno()));
/* not a fatal error */
raddr = addr_get_ip(curr_laddr);
rport = addr_get_port(curr_laddr);
}
else
{
if (rsaddr.sin_family!=PSOCK_AF_INET)
{
eventlog(eventlog_level_error,"sd_accept","local address returned with bad address family %d",(int)rsaddr.sin_family);
/* not a fatal error */
raddr = addr_get_ip(curr_laddr);
rport = addr_get_port(curr_laddr);
}
else
{
raddr = ntohl(rsaddr.sin_addr.s_addr);
rport = ntohs(rsaddr.sin_port);
}
}
}
if (psock_ctl(csocket,PSOCK_NONBLOCK)<0)
{
eventlog(eventlog_level_error,"sd_accept","[%d] could not set TCP socket to non-blocking mode (closing connection) (psock_ctl: %s)",csocket,strerror(psock_errno()));
psock_close(csocket);
return -1;
}
{
t_connection * c;
if (!(c = conn_create(csocket,usocket,raddr,rport,addr_get_ip(curr_laddr),addr_get_port(curr_laddr),ntohl(caddr.sin_addr.s_addr),ntohs(caddr.sin_port))))
{
eventlog(eventlog_level_error,"sd_accept","[%d] unable to create new connection (closing connection)",csocket);
psock_close(csocket);
return -1;
}
eventlog(eventlog_level_debug,"sd_accept","[%d] client connected to a %s listening address",csocket,laddr_type_get_str(laddr_info->type));
switch (laddr_info->type)
{
case laddr_type_irc:
conn_set_class(c,conn_class_irc);
conn_set_state(c,conn_state_connected);
break;
case laddr_type_telnet:
conn_set_class(c,conn_class_telnet);
conn_set_state(c,conn_state_connected);
break;
case laddr_type_bnet:
default:
/* We have to wait for an initial "magic" byte on bnet connections to
* tell us exactly what connection class we are dealing with.
*/
break;
}
}
return 0;
}
int main(void)
{
struct vlc_http_stream *s, *s2;
struct vlc_http_msg *m;
struct block_t *b;
uint_fast32_t sid = -1; /* Second guessed stream IDs :-/ */
conn_create();
conn_destroy();
conn_create();
conn_send(vlc_h2_frame_ping(42));
conn_expect(PING);
/* Test rejected stream */
sid += 2;
s = stream_open();
assert(s != NULL);
conn_expect(HEADERS);
conn_send(vlc_h2_frame_rst_stream(sid, VLC_H2_REFUSED_STREAM));
m = vlc_http_stream_read_headers(s);
assert(m == NULL);
b = vlc_http_stream_read(s);
assert(b == NULL);
vlc_http_stream_close(s, false);
conn_expect(RST_STREAM);
/* Test accepted stream */
sid += 2;
s = stream_open();
assert(s != NULL);
stream_reply(sid, false);
m = vlc_http_msg_get_initial(s);
assert(m != NULL);
vlc_http_msg_destroy(m);
stream_data(3, "Hello ", false); /* late data */
stream_data(3, "world!", true);
conn_expect(HEADERS);
conn_expect(RST_STREAM);
conn_expect(RST_STREAM);
conn_expect(RST_STREAM);
/* Test continuation then accepted stream */
sid += 2;
s = stream_open();
assert(s != NULL);
stream_continuation(sid);
m = vlc_http_msg_get_initial(s);
assert(m != NULL);
assert(vlc_http_msg_get_status(m) == 100);
stream_reply(sid, false);
m = vlc_http_msg_iterate(m);
assert(m != NULL);
stream_data(sid, "Hello ", false);
stream_data(sid, "world!", true);
stream_data(sid, "Stray message", false); /* data after EOS */
b = vlc_http_msg_read(m);
assert(b != NULL);
block_Release(b);
b = vlc_http_msg_read(m);
assert(b != NULL);
block_Release(b);
b = vlc_http_msg_read(m);
assert(b == NULL);
vlc_http_msg_destroy(m);
conn_expect(HEADERS);
conn_expect(RST_STREAM);
conn_expect(RST_STREAM);
/* Test accepted stream after continuation */
sid += 2;
s = stream_open();
assert(s != NULL);
stream_continuation(sid);
stream_reply(sid, true);
sid += 2;
s2 = stream_open(); /* second stream to enforce test timing/ordering */
assert(s2 != NULL);
stream_reply(sid, true);
m = vlc_http_msg_get_initial(s2);
assert(m != NULL);
vlc_http_msg_destroy(m);
m = vlc_http_msg_get_initial(s);
assert(m != NULL);
assert(vlc_http_msg_get_status(m) == 200);
b = vlc_http_msg_read(m);
assert(b == NULL);
vlc_http_msg_destroy(m);
conn_expect(HEADERS);
conn_expect(HEADERS);
conn_expect(RST_STREAM);
conn_expect(RST_STREAM);
/* Test nonexistent stream reset */
conn_send(vlc_h2_frame_rst_stream(sid + 100, VLC_H2_REFUSED_STREAM));
/* Test multiple streams in non-LIFO order */
sid += 2;
s = stream_open();
assert(s != NULL);
sid += 2;
s2 = stream_open();
assert(s2 != NULL);
stream_reply(sid, false);
stream_reply(sid - 2, true);
stream_data(sid, "Discarded", false); /* not read data */
m = vlc_http_msg_get_initial(s);
assert(m != NULL);
vlc_http_msg_destroy(m);
m = vlc_http_msg_get_initial(s2);
assert(m != NULL);
vlc_http_msg_destroy(m);
conn_expect(HEADERS);
conn_expect(HEADERS);
conn_expect(RST_STREAM);
conn_expect(RST_STREAM);
/* might or might not seen one or two extra RST_STREAM now */
/* Test graceful connection termination */
sid += 2;
s = stream_open();
assert(s != NULL);
conn_send(vlc_h2_frame_goaway(sid - 2, VLC_H2_NO_ERROR));
m = vlc_http_stream_read_headers(s);
assert(m == NULL);
/* Test stream after connection shut down */
assert(stream_open() == NULL);
/* Test releasing connection before stream */
conn_destroy();
vlc_http_stream_close(s, false);
return 0;
}
struct wtpman *wtpman_create(int socklistindex, struct sockaddr *srcaddr)
{
struct wtpman *wtpman;
wtpman = malloc(sizeof(struct wtpman));
if (!wtpman)
return 0;
memset(wtpman, 0, sizeof(struct wtpman));
int replyfd;
if (socklist[socklistindex].type != SOCKLIST_UNICAST_SOCKET) {
int port = sock_getport(&socklist[socklistindex].addr);
replyfd = socklist_find_reply_socket(srcaddr, port);
if (replyfd == -1) {
cw_log(LOG_ERR, "Can't find reply socket for request from %s",
sock_addr2str(srcaddr));
free(wtpman);
return NULL;
}
} else {
replyfd = socklist[socklistindex].sockfd;
}
int sockfd = replyfd; //socklist[socklistindex].reply_sockfd;
struct sockaddr dbgaddr;
socklen_t dbgaddrl = sizeof(dbgaddr);
getsockname(sockfd, &dbgaddr, &dbgaddrl);
cw_dbg(DBG_INFO, "Creating wtpman on socket %d, %s:%d", sockfd,
sock_addr2str(&dbgaddr), sock_getport(&dbgaddr));
//extern int conn_process_packet2(struct conn *conn, uint8_t * packet, int len,
// struct sockaddr *from);
wtpman->conn = conn_create(sockfd, srcaddr, 100);
wtpman->conn->data_sock = socklist[socklistindex].data_sockfd;
sock_copyaddr(&wtpman->conn->data_addr, (struct sockaddr *) &wtpman->conn->addr);
// wtpman->conn->process_packet = conn_process_packet2;
if (!wtpman->conn) {
wtpman_destroy(wtpman);
return NULL;
}
wtpman->conn->mods = conf_mods;
wtpman->conn->strict_capwap = conf_strict_capwap;
wtpman->conn->strict_hdr = conf_strict_headers;
wtpman->conn->radios = mbag_i_create();
wtpman->conn->radios_upd = mbag_i_create();
wtpman->conn->local = ac_config;
//wtpman->conn->capwap_mode=0; //CW_MODE_STD; //CISCO;
wtpman->conn->capwap_mode = CW_MODE_CISCO;
//wtpman->conn->strict_capwap_hdr=0;
return wtpman;
}
