/**
* Inserts value at the end of the list
*/
void list_append(List list, void *value){
if (list->last == NULL) {
list->last = list->first = link_create(value, NULL);
}else{
list->last = list->last->next = link_create(value, NULL);
}
}
void insert(link_t* root,int data,int n){
link_t* p = link_create(); //create a pointer.
p = root;
while (n-2) //post_insert.
{
n--;
p = p->next;
}
link_t* node = link_create();
node->next = p->next;
p->next = node;
node->data = data;
}
int main(int argc, char **argv)
{
unsigned char retVal;
int i;
LINK_NODE *head = NULL;
if( NULL == (head=link_create()) )
return -1;
for(i=1; i<5; i++)
{
retVal = link_insert(head, i, i);
if(COMMON_OK != retVal)
{
printf("Insert node[%d] failure, retVal = 0x%02x\n", i, retVal);
break;
}
}
link_traverse(head);
link_revers(head);
printf("After revers...........................................................\n");
link_traverse(head);
printf("Destroy the linker now.\n");
link_destroy(head);
return 0;
}
/*
* Add the item to the list before the passed link
* and return the new link.
* Note that the link must have come from this linked
* list or bad things will happen!
*/
LINK_T *linklst_add_before(void *item, LINK_T *after, LINKLST_T *linklst) {
LINK_T *before = after->before;
LINK_T *link = link_create(before, after, item);
if (before == NULL) linklst->first = link;
linklst->size += 1;
return link;
}
/*
* Add the item to the list after the passed link
* and return the new link.
* Note that the link must have come from this linked
* list or bad things will happen!
*/
LINK_T *linklst_add_after(void *item, LINK_T *before, LINKLST_T *linklst) {
LINK_T *after = before->after;
LINK_T *link = link_create(before, after, item);
if (after == NULL) linklst->last = link;
linklst->size += 1;
return link;
}
struct link *link_accept(struct link *master, time_t stoptime)
{
struct link *link = 0;
link = link_create();
if(!link)
goto failure;
while(1) {
if(!link_sleep(master, stoptime, 1, 0))
goto failure;
link->fd = accept(master->fd, 0, 0);
break;
}
if(!link_nonblocking(link, 1))
goto failure;
if(!link_address_remote(link, link->raddr, &link->rport))
goto failure;
link_squelch();
debug(D_TCP, "got connection from %s:%d", link->raddr, link->rport);
return link;
failure:
if(link)
link_close(link);
return 0;
}
/*
* Pushes the item on the front of the linked list
* and returns the new link.
*/
LINK_T *linklst_push(void *item, LINKLST_T *linklst) {
LINK_T *after = linklst->first;
LINK_T *before = NULL;
LINK_T *link = link_create(before, after, item);
linklst->first = link;
if (after == NULL) linklst->last = link;
linklst->size += 1;
return link;
}
struct link *link_serve_address(const char *addr, int port)
{
struct link *link = 0;
struct sockaddr_in address;
int success;
int value;
link = link_create();
if(!link)
goto failure;
link->fd = socket(AF_INET, SOCK_STREAM, 0);
if(link->fd < 0)
goto failure;
value = 1;
setsockopt(link->fd, SOL_SOCKET, SO_REUSEADDR, (void *) &value, sizeof(value));
link_window_configure(link);
if(addr != 0 || port != LINK_PORT_ANY) {
memset(&address, 0, sizeof(address));
#if defined(CCTOOLS_OPSYS_DARWIN)
address.sin_len = sizeof(address);
#endif
address.sin_family = AF_INET;
address.sin_port = htons(port);
if(addr) {
string_to_ip_address(addr, (unsigned char *) &address.sin_addr.s_addr);
} else {
address.sin_addr.s_addr = htonl(INADDR_ANY);
}
success = bind(link->fd, (struct sockaddr *) &address, sizeof(address));
if(success < 0)
goto failure;
}
success = listen(link->fd, 5);
if(success < 0)
goto failure;
if(!link_nonblocking(link, 1))
goto failure;
debug(D_TCP, "listening on port %d", port);
return link;
failure:
if(link)
link_close(link);
return 0;
}
struct link *link_attach_to_fd(int fd)
{
struct link *l = link_create();
if(fd < 0) {
link_close(l);
return NULL;
}
l->fd = fd;
l->type = LINK_TYPE_FILE;
return l;
}
/* finds a link, creating one if necessary */
link_t *links_catalog_find_create(const link_id_t *key)
{
link_t *link;
g_assert(all_links);
g_assert(key);
link = links_catalog_find(key);
if (!link)
{
link = link_create(key);
links_catalog_insert(link);
}
return link;
}
struct link *link_attach(int fd)
{
struct link *l = link_create();
if(!l)
return 0;
l->fd = fd;
if(link_address_remote(l, l->raddr, &l->rport)) {
debug(D_TCP, "attached to %s:%d", l->raddr, l->rport);
return l;
} else {
l->fd = -1;
link_close(l);
return 0;
}
}
u_link *u_link_connect(mowgli_eventloop_t *ev, u_link_block *block,
const struct sockaddr *addr, socklen_t addrlen)
{
u_link *link = link_create();
u_conn *conn;
if (!(conn = u_conn_connect(ev, &u_link_conn_ctx, link, 0,
addr, addrlen))) {
link_destroy(link);
return NULL;
}
link->conf.link = block;
u_log(LG_VERBOSE, "connecting to %s", conn->ip);
return link;
}
static void accept_ready(mowgli_eventloop_t *ev, mowgli_eventloop_io_t *io,
mowgli_eventloop_io_dir_t dir, void *priv)
{
mowgli_eventloop_pollable_t *poll = mowgli_eventloop_io_pollable(io);
u_conn *conn;
u_link *link;
sync_time();
link = link_create();
if (!(conn = u_conn_accept(ev, &u_link_conn_ctx, link, 0, poll->fd))) {
link_destroy(link);
/* TODO: close listener, maybe? */
return;
}
u_log(LG_VERBOSE, "new connection from %s", conn->ip);
}
static bool create_links(
struct dc *dc,
uint32_t num_virtual_links)
{
int i;
int connectors_num;
struct dc_bios *bios = dc->ctx->dc_bios;
dc->link_count = 0;
connectors_num = bios->funcs->get_connectors_number(bios);
if (connectors_num > ENUM_ID_COUNT) {
dm_error(
"DC: Number of connectors %d exceeds maximum of %d!\n",
connectors_num,
ENUM_ID_COUNT);
return false;
}
if (connectors_num == 0 && num_virtual_links == 0) {
dm_error("DC: Number of connectors is zero!\n");
}
dm_output_to_console(
"DC: %s: connectors_num: physical:%d, virtual:%d\n",
__func__,
connectors_num,
num_virtual_links);
for (i = 0; i < connectors_num; i++) {
struct link_init_data link_init_params = {0};
struct dc_link *link;
link_init_params.ctx = dc->ctx;
/* next BIOS object table connector */
link_init_params.connector_index = i;
link_init_params.link_index = dc->link_count;
link_init_params.dc = dc;
link = link_create(&link_init_params);
if (link) {
dc->links[dc->link_count] = link;
link->dc = dc;
++dc->link_count;
}
}
for (i = 0; i < num_virtual_links; i++) {
struct dc_link *link = kzalloc(sizeof(*link), GFP_KERNEL);
struct encoder_init_data enc_init = {0};
if (link == NULL) {
BREAK_TO_DEBUGGER();
goto failed_alloc;
}
link->link_index = dc->link_count;
dc->links[dc->link_count] = link;
dc->link_count++;
link->ctx = dc->ctx;
link->dc = dc;
link->connector_signal = SIGNAL_TYPE_VIRTUAL;
link->link_id.type = OBJECT_TYPE_CONNECTOR;
link->link_id.id = CONNECTOR_ID_VIRTUAL;
link->link_id.enum_id = ENUM_ID_1;
link->link_enc = kzalloc(sizeof(*link->link_enc), GFP_KERNEL);
if (!link->link_enc) {
BREAK_TO_DEBUGGER();
goto failed_alloc;
}
link->link_status.dpcd_caps = &link->dpcd_caps;
enc_init.ctx = dc->ctx;
enc_init.channel = CHANNEL_ID_UNKNOWN;
enc_init.hpd_source = HPD_SOURCEID_UNKNOWN;
enc_init.transmitter = TRANSMITTER_UNKNOWN;
enc_init.connector = link->link_id;
enc_init.encoder.type = OBJECT_TYPE_ENCODER;
enc_init.encoder.id = ENCODER_ID_INTERNAL_VIRTUAL;
enc_init.encoder.enum_id = ENUM_ID_1;
virtual_link_encoder_construct(link->link_enc, &enc_init);
}
return true;
failed_alloc:
return false;
}
int main(int argc, char** argv)
{
int result;
XIO_HANDLE sasl_io = NULL;
CONNECTION_HANDLE connection = NULL;
SESSION_HANDLE session = NULL;
LINK_HANDLE link = NULL;
MESSAGE_RECEIVER_HANDLE message_receiver = NULL;
amqpalloc_set_memory_tracing_enabled(true);
if (platform_init() != 0)
{
result = -1;
}
else
{
size_t last_memory_used = 0;
/* create SASL plain handler */
SASL_PLAIN_CONFIG sasl_plain_config = { EH_KEY_NAME, EH_KEY, NULL };
SASL_MECHANISM_HANDLE sasl_mechanism_handle = saslmechanism_create(saslplain_get_interface(), &sasl_plain_config);
XIO_HANDLE tls_io;
/* create the TLS IO */
TLSIO_CONFIG tls_io_config = { EH_HOST, 5671 };
const IO_INTERFACE_DESCRIPTION* tlsio_interface = platform_get_default_tlsio();
tls_io = xio_create(tlsio_interface, &tls_io_config, NULL);
/* create the SASL client IO using the TLS IO */
SASLCLIENTIO_CONFIG sasl_io_config = { tls_io, sasl_mechanism_handle };
sasl_io = xio_create(saslclientio_get_interface_description(), &sasl_io_config, NULL);
/* create the connection, session and link */
connection = connection_create(sasl_io, EH_HOST, "whatever", NULL, NULL);
session = session_create(connection, NULL, NULL);
/* set incoming window to 100 for the session */
session_set_incoming_window(session, 100);
AMQP_VALUE source = messaging_create_source("amqps://" EH_HOST "/ingress/ConsumerGroups/$Default/Partitions/0");
AMQP_VALUE target = messaging_create_target("ingress-rx");
link = link_create(session, "receiver-link", role_receiver, source, target);
link_set_rcv_settle_mode(link, receiver_settle_mode_first);
amqpvalue_destroy(source);
amqpvalue_destroy(target);
/* create a message receiver */
message_receiver = messagereceiver_create(link, NULL, NULL);
if ((message_receiver == NULL) ||
(messagereceiver_open(message_receiver, on_message_received, message_receiver) != 0))
{
result = -1;
}
else
{
while (true)
{
size_t current_memory_used;
size_t maximum_memory_used;
connection_dowork(connection);
current_memory_used = amqpalloc_get_current_memory_used();
maximum_memory_used = amqpalloc_get_maximum_memory_used();
if (current_memory_used != last_memory_used)
{
printf("Current memory usage:%lu (max:%lu)\r\n", (unsigned long)current_memory_used, (unsigned long)maximum_memory_used);
last_memory_used = current_memory_used;
}
}
result = 0;
}
messagereceiver_destroy(message_receiver);
link_destroy(link);
session_destroy(session);
connection_destroy(connection);
platform_deinit();
printf("Max memory usage:%lu\r\n", (unsigned long)amqpalloc_get_maximum_memory_used());
printf("Current memory usage:%lu\r\n", (unsigned long)amqpalloc_get_current_memory_used());
#ifdef _CRTDBG_MAP_ALLOC
_CrtDumpMemoryLeaks();
#endif
}
return result;
}
struct link *link_connect(const char *addr, int port, time_t stoptime)
{
struct sockaddr_in address;
struct link *link = 0;
int result;
int save_errno;
link = link_create();
if(!link)
goto failure;
link_squelch();
memset(&address, 0, sizeof(address));
#if defined(CCTOOLS_OPSYS_DARWIN)
address.sin_len = sizeof(address);
#endif
address.sin_family = AF_INET;
address.sin_port = htons(port);
if(!string_to_ip_address(addr, (unsigned char *) &address.sin_addr))
goto failure;
link->fd = socket(AF_INET, SOCK_STREAM, 0);
if(link->fd < 0)
goto failure;
link_window_configure(link);
/* sadly, cygwin does not do non-blocking connect correctly */
#ifdef CCTOOLS_OPSYS_CYGWIN
if(!link_nonblocking(link, 0))
goto failure;
#else
if(!link_nonblocking(link, 1))
goto failure;
#endif
debug(D_TCP, "connecting to %s:%d", addr, port);
while(1) {
// First attempt a non-blocking connect
result = connect(link->fd, (struct sockaddr *) &address, sizeof(address));
// On many platforms, non-blocking connect sets errno in unexpected ways:
// On OSX, result=-1 and errno==EISCONN indicates a successful connection.
if(result<0 && errno==EISCONN) result=0;
// On BSD-derived systems, failure to connect is indicated by errno = EINVAL.
// Set it to something more explanatory.
if(result<0 && errno==EINVAL) errno=ECONNREFUSED;
// Otherwise, a non-temporary errno should cause us to bail out.
if(result<0 && !errno_is_temporary(errno)) break;
// If the remote address is valid, we are connected no matter what.
if(link_address_remote(link, link->raddr, &link->rport)) {
debug(D_TCP, "made connection to %s:%d", link->raddr, link->rport);
#ifdef CCTOOLS_OPSYS_CYGWIN
link_nonblocking(link, 1);
#endif
return link;
}
// if the time has expired, bail out
if( time(0) >= stoptime ) {
errno = ETIMEDOUT;
break;
}
// wait for some activity on the socket.
link_sleep(link, stoptime, 0, 1);
// No matter how the sleep ends, we want to go back to the top
// and call connect again to get a proper errno.
}
debug(D_TCP, "connection to %s:%d failed (%s)", addr, port, strerror(errno));
failure:
save_errno = errno;
if(link)
link_close(link);
errno = save_errno;
return 0;
}
struct link *link_serve_address(const char *addr, int port)
{
struct link *link = 0;
struct sockaddr_in address;
int success;
int value;
link = link_create();
if(!link)
goto failure;
link->fd = socket(AF_INET, SOCK_STREAM, 0);
if(link->fd < 0)
goto failure;
value = fcntl(link->fd, F_GETFD);
if (value == -1)
goto failure;
value |= FD_CLOEXEC;
if (fcntl(link->fd, F_SETFD, value) == -1)
goto failure;
value = 1;
setsockopt(link->fd, SOL_SOCKET, SO_REUSEADDR, (void *) &value, sizeof(value));
link_window_configure(link);
memset(&address, 0, sizeof(address));
#if defined(CCTOOLS_OPSYS_DARWIN)
address.sin_len = sizeof(address);
#endif
address.sin_family = AF_INET;
if(addr) {
string_to_ip_address(addr, (unsigned char *) &address.sin_addr.s_addr);
} else {
address.sin_addr.s_addr = htonl(INADDR_ANY);
}
int low = TCP_LOW_PORT_DEFAULT;
int high = TCP_HIGH_PORT_DEFAULT;
if(port < 1) {
const char *lowstr = getenv("TCP_LOW_PORT");
if (lowstr)
low = atoi(lowstr);
const char *highstr = getenv("TCP_HIGH_PORT");
if (highstr)
high = atoi(highstr);
} else {
low = high = port;
}
if(high < low)
fatal("high port %d is less than low port %d in range", high, low);
for (port = low; port <= high; port++) {
address.sin_port = htons(port);
success = bind(link->fd, (struct sockaddr *) &address, sizeof(address));
if(success == -1) {
if(errno == EADDRINUSE) {
//If a port is specified, fail!
if (low == high) {
goto failure;
} else {
continue;
}
} else {
goto failure;
}
}
break;
}
success = listen(link->fd, 5);
if(success < 0)
goto failure;
if(!link_nonblocking(link, 1))
goto failure;
debug(D_TCP, "listening on port %d", port);
return link;
failure:
if(link)
link_close(link);
return 0;
}
u_link *u_link_from_json(mowgli_json_t *jl)
{
u_link *link;
mowgli_json_t *jcookie, *jconn;
mowgli_string_t *jpass, *jslinkname;
ssize_t sz;
link = link_create();
if (json_ogetu(jl, "flags", &link->flags) < 0)
goto error;
if (json_ogetu(jl, "type", &link->type) < 0)
goto error;
if (json_ogeti(jl, "sendq", &link->sendq) < 0)
goto error;
if ((sz = json_ogetb64(jl, "ibuf", link->ibuf, IBUFSIZE)) < 0)
goto error;
link->ibuflen = sz;
link->ibuf[link->ibuflen] = '\0';
jpass = json_ogets(jl, "pass");
if (jpass) {
link->pass = malloc(jpass->pos+1);
memcpy(link->pass, jpass->str, jpass->pos);
link->pass[jpass->pos] = '\0';
}
jcookie = json_ogeto(jl, "ck_sendto");
if (!jcookie)
goto error;
if (u_cookie_from_json(jcookie, &link->ck_sendto) < 0)
goto error;
jconn = json_ogeto(jl, "conn");
if (!jconn)
goto error;
link->conn = u_conn_from_json(base_ev, &u_link_conn_ctx, link, jconn);
if (!link->conn)
goto error;
link->conn->priv = link;
/* This must run after the config has been loaded. */
switch (link->type) {
case LINK_USER:
/* If the user is post-registration, re-find his auth block. */
if (link->flags & U_LINK_REGISTERED) {
/* XXX: Should this be in user.c? */
link->conf.auth = u_find_auth(link);
if (!link->conf.auth)
goto error;
}
break;
case LINK_SERVER:
jslinkname = json_ogets(jl, "server_link_block_name");
if (!jslinkname)
goto error;
/* mowgli_string is NULL-terminated. We needn't care about NULLs. */
link->conf.link = u_find_link(jslinkname->str);
if (!link->conf.link)
goto error;
break;
default:
u_log(LG_SEVERE, "unexpected link type %d", link->type);
abort();
}
return link;
error:
if (link) {
free(link->pass);
free(link);
}
return NULL;
}
AMQP_MANAGEMENT_HANDLE amqpmanagement_create(SESSION_HANDLE session, const char* management_node, ON_AMQP_MANAGEMENT_STATE_CHANGED on_amqp_management_state_changed, void* callback_context)
{
AMQP_MANAGEMENT_INSTANCE* result;
if (session == NULL)
{
result = NULL;
}
else
{
result = (AMQP_MANAGEMENT_INSTANCE*)amqpalloc_malloc(sizeof(AMQP_MANAGEMENT_INSTANCE));
if (result != NULL)
{
result->session = session;
result->sender_connected = 0;
result->receiver_connected = 0;
result->operation_message_count = 0;
result->operation_messages = NULL;
result->on_amqp_management_state_changed = on_amqp_management_state_changed;
result->callback_context = callback_context;
AMQP_VALUE source = messaging_create_source(management_node);
if (source == NULL)
{
amqpalloc_free(result);
result = NULL;
}
else
{
AMQP_VALUE target = messaging_create_target(management_node);
if (target == NULL)
{
amqpalloc_free(result);
result = NULL;
}
else
{
static const char* sender_suffix = "-sender";
char* sender_link_name = (char*)amqpalloc_malloc(strlen(management_node) + strlen(sender_suffix) + 1);
if (sender_link_name == NULL)
{
result = NULL;
}
else
{
static const char* receiver_suffix = "-receiver";
(void)strcpy(sender_link_name, management_node);
(void)strcat(sender_link_name, sender_suffix);
char* receiver_link_name = (char*)amqpalloc_malloc(strlen(management_node) + strlen(receiver_suffix) + 1);
if (receiver_link_name == NULL)
{
result = NULL;
}
else
{
(void)strcpy(receiver_link_name, management_node);
(void)strcat(receiver_link_name, receiver_suffix);
result->sender_link = link_create(session, "cbs-sender", role_sender, source, target);
if (result->sender_link == NULL)
{
amqpalloc_free(result);
result = NULL;
}
else
{
result->receiver_link = link_create(session, "cbs-receiver", role_receiver, source, target);
if (result->receiver_link == NULL)
{
link_destroy(result->sender_link);
amqpalloc_free(result);
result = NULL;
}
else
{
if ((link_set_max_message_size(result->sender_link, 65535) != 0) ||
(link_set_max_message_size(result->receiver_link, 65535) != 0))
{
link_destroy(result->sender_link);
link_destroy(result->receiver_link);
amqpalloc_free(result);
result = NULL;
}
else
{
result->message_sender = messagesender_create(result->sender_link, on_message_sender_state_changed, result, NULL);
if (result->message_sender == NULL)
{
link_destroy(result->sender_link);
link_destroy(result->receiver_link);
amqpalloc_free(result);
result = NULL;
}
else
{
result->message_receiver = messagereceiver_create(result->receiver_link, on_message_receiver_state_changed, result);
if (result->message_receiver == NULL)
{
messagesender_destroy(result->message_sender);
link_destroy(result->sender_link);
link_destroy(result->receiver_link);
amqpalloc_free(result);
result = NULL;
}
else
{
result->next_message_id = 0;
}
}
}
}
}
amqpalloc_free(receiver_link_name);
}
amqpalloc_free(sender_link_name);
}
amqpvalue_destroy(target);
}
amqpvalue_destroy(source);
}
}
}
return result;
}
struct link *link_connect(const char *addr, int port, time_t stoptime)
{
struct sockaddr_in address;
struct link *link = 0;
int result;
int save_errno;
link = link_create();
if(!link)
goto failure;
link_squelch();
memset(&address, 0, sizeof(address));
#if defined(CCTOOLS_OPSYS_DARWIN)
address.sin_len = sizeof(address);
#endif
address.sin_family = AF_INET;
address.sin_port = htons(port);
if(!string_to_ip_address(addr, (unsigned char *) &address.sin_addr))
goto failure;
link->fd = socket(AF_INET, SOCK_STREAM, 0);
if(link->fd < 0)
goto failure;
link_window_configure(link);
/* sadly, cygwin does not do non-blocking connect correctly */
#ifdef CCTOOLS_OPSYS_CYGWIN
if(!link_nonblocking(link, 0))
goto failure;
#else
if(!link_nonblocking(link, 1))
goto failure;
#endif
debug(D_TCP, "connecting to %s:%d", addr, port);
do {
result = connect(link->fd, (struct sockaddr *) &address, sizeof(address));
/* On some platforms, errno is not set correctly. */
/* If the remote address can be found, then we are really connected. */
/* Also, on bsd-derived systems, failure to connect is indicated by a second connect returning EINVAL. */
if(result < 0 && !errno_is_temporary(errno)) {
if(errno == EINVAL)
errno = ECONNREFUSED;
break;
}
if(link_address_remote(link, link->raddr, &link->rport)) {
debug(D_TCP, "made connection to %s:%d", link->raddr, link->rport);
#ifdef CCTOOLS_OPSYS_CYGWIN
link_nonblocking(link, 1);
#endif
return link;
}
} while(link_sleep(link, stoptime, 0, 1));
debug(D_TCP, "connection to %s:%d failed (%s)", addr, port, strerror(errno));
failure:
save_errno = errno;
if(link)
link_close(link);
errno = save_errno;
return 0;
}
int main(int argc, char** argv)
{
int result;
(void)argc;
(void)argv;
if (platform_init() != 0)
{
result = -1;
}
else
{
XIO_HANDLE sasl_io;
CONNECTION_HANDLE connection;
SESSION_HANDLE session;
LINK_HANDLE link;
MESSAGE_SENDER_HANDLE message_sender;
MESSAGE_HANDLE message;
size_t last_memory_used = 0;
/* create SASL PLAIN handler */
SASL_MECHANISM_HANDLE sasl_mechanism_handle = saslmechanism_create(saslmssbcbs_get_interface(), NULL);
XIO_HANDLE tls_io;
STRING_HANDLE sas_key_name;
STRING_HANDLE sas_key_value;
STRING_HANDLE resource_uri;
STRING_HANDLE encoded_resource_uri;
STRING_HANDLE sas_token;
BUFFER_HANDLE buffer;
TLSIO_CONFIG tls_io_config = { EH_HOST, 5671 };
const IO_INTERFACE_DESCRIPTION* tlsio_interface;
SASLCLIENTIO_CONFIG sasl_io_config;
time_t currentTime;
size_t expiry_time;
CBS_HANDLE cbs;
AMQP_VALUE source;
AMQP_VALUE target;
unsigned char hello[] = { 'H', 'e', 'l', 'l', 'o' };
BINARY_DATA binary_data;
gballoc_init();
/* create the TLS IO */
tlsio_interface = platform_get_default_tlsio();
tls_io = xio_create(tlsio_interface, &tls_io_config);
/* create the SASL client IO using the TLS IO */
sasl_io_config.underlying_io = tls_io;
sasl_io_config.sasl_mechanism = sasl_mechanism_handle;
sasl_io = xio_create(saslclientio_get_interface_description(), &sasl_io_config);
/* create the connection, session and link */
connection = connection_create(sasl_io, EH_HOST, "some", NULL, NULL);
session = session_create(connection, NULL, NULL);
session_set_incoming_window(session, 2147483647);
session_set_outgoing_window(session, 65536);
/* Construct a SAS token */
sas_key_name = STRING_construct(EH_KEY_NAME);
/* unfortunately SASToken wants an encoded key - this should be fixed at a later time */
buffer = BUFFER_create((unsigned char*)EH_KEY, strlen(EH_KEY));
sas_key_value = Base64_Encoder(buffer);
BUFFER_delete(buffer);
resource_uri = STRING_construct("sb://" EH_HOST "/" EH_NAME "/publishers/" EH_PUBLISHER);
encoded_resource_uri = URL_EncodeString(STRING_c_str(resource_uri));
/* Make a token that expires in one hour */
currentTime = time(NULL);
expiry_time = (size_t)(difftime(currentTime, 0) + 3600);
sas_token = SASToken_Create(sas_key_value, encoded_resource_uri, sas_key_name, expiry_time);
cbs = cbs_create(session);
if (cbs_open_async(cbs, on_cbs_open_complete, cbs, on_cbs_error, cbs) == 0)
{
(void)cbs_put_token_async(cbs, "servicebus.windows.net:sastoken", "sb://" EH_HOST "/" EH_NAME "/publishers/" EH_PUBLISHER, STRING_c_str(sas_token), on_cbs_put_token_complete, cbs);
while (!auth)
{
size_t current_memory_used;
size_t maximum_memory_used;
connection_dowork(connection);
current_memory_used = gballoc_getCurrentMemoryUsed();
maximum_memory_used = gballoc_getMaximumMemoryUsed();
if (current_memory_used != last_memory_used)
{
(void)printf("Current memory usage:%lu (max:%lu)\r\n", (unsigned long)current_memory_used, (unsigned long)maximum_memory_used);
last_memory_used = current_memory_used;
}
}
}
STRING_delete(sas_token);
STRING_delete(sas_key_name);
STRING_delete(sas_key_value);
STRING_delete(resource_uri);
STRING_delete(encoded_resource_uri);
source = messaging_create_source("ingress");
target = messaging_create_target("amqps://" EH_HOST "/" EH_NAME);
link = link_create(session, "sender-link", role_sender, source, target);
link_set_snd_settle_mode(link, sender_settle_mode_settled);
(void)link_set_max_message_size(link, 65536);
amqpvalue_destroy(source);
amqpvalue_destroy(target);
message = message_create();
binary_data.bytes = hello;
binary_data.length = sizeof(hello);
message_add_body_amqp_data(message, binary_data);
/* create a message sender */
message_sender = messagesender_create(link, NULL, NULL);
if (messagesender_open(message_sender) == 0)
{
uint32_t i;
bool keep_running = true;
tickcounter_ms_t start_time;
TICK_COUNTER_HANDLE tick_counter = tickcounter_create();
if (tickcounter_get_current_ms(tick_counter, &start_time) != 0)
{
(void)printf("Error getting start time\r\n");
}
else
{
for (i = 0; i < msg_count; i++)
{
(void)messagesender_send(message_sender, message, on_message_send_complete, message);
}
message_destroy(message);
while (keep_running)
{
size_t current_memory_used;
size_t maximum_memory_used;
connection_dowork(connection);
current_memory_used = gballoc_getCurrentMemoryUsed();
maximum_memory_used = gballoc_getMaximumMemoryUsed();
if (current_memory_used != last_memory_used)
{
(void)printf("Current memory usage:%lu (max:%lu)\r\n", (unsigned long)current_memory_used, (unsigned long)maximum_memory_used);
last_memory_used = current_memory_used;
}
if (sent_messages == msg_count)
{
break;
}
}
{
tickcounter_ms_t end_time;
if (tickcounter_get_current_ms(tick_counter, &end_time) != 0)
{
(void)printf("Error getting end time\r\n");
}
else
{
(void)printf("Send %u messages in %lu ms: %.02f msgs/sec\r\n", (unsigned int)msg_count, (unsigned long)(end_time - start_time), (float)msg_count / ((float)(end_time - start_time) / 1000));
}
}
}
}
messagesender_destroy(message_sender);
link_destroy(link);
session_destroy(session);
connection_destroy(connection);
xio_destroy(sasl_io);
xio_destroy(tls_io);
saslmechanism_destroy(sasl_mechanism_handle);
platform_deinit();
(void)printf("Max memory usage:%lu\r\n", (unsigned long)gballoc_getCurrentMemoryUsed());
(void)printf("Current memory usage:%lu\r\n", (unsigned long)gballoc_getMaximumMemoryUsed());
gballoc_deinit();
result = 0;
}
return result;
}
/**
* Inserts value at the start of the list
*/
void list_prepend(List list, void *value) {
list->first = link_create(value, list->first);
if (list->last == NULL) {
list->last = list->first;
}
}
void list_inject(struct link *link, void *value) {
link->next = link_create(value, link->next);
}
int main(int argc, char** argv)
{
int result;
(void)argc, argv;
amqpalloc_set_memory_tracing_enabled(true);
if (platform_init() != 0)
{
result = -1;
}
else
{
XIO_HANDLE sasl_io;
CONNECTION_HANDLE connection;
SESSION_HANDLE session;
LINK_HANDLE link;
MESSAGE_SENDER_HANDLE message_sender;
MESSAGE_HANDLE message;
size_t last_memory_used = 0;
/* create SASL PLAIN handler */
SASL_PLAIN_CONFIG sasl_plain_config = { EH_KEY_NAME, EH_KEY, NULL };
SASL_MECHANISM_HANDLE sasl_mechanism_handle = saslmechanism_create(saslplain_get_interface(), &sasl_plain_config);
XIO_HANDLE tls_io;
/* create the TLS IO */
TLSIO_CONFIG tls_io_config = { EH_HOST, 5671 };
const IO_INTERFACE_DESCRIPTION* tlsio_interface = platform_get_default_tlsio();
tls_io = xio_create(tlsio_interface, &tls_io_config);
/* create the SASL client IO using the TLS IO */
SASLCLIENTIO_CONFIG sasl_io_config;
sasl_io_config.underlying_io = tls_io;
sasl_io_config.sasl_mechanism = sasl_mechanism_handle;
sasl_io = xio_create(saslclientio_get_interface_description(), &sasl_io_config);
/* create the connection, session and link */
connection = connection_create(sasl_io, EH_HOST, "some", NULL, NULL);
session = session_create(connection, NULL, NULL);
session_set_incoming_window(session, 2147483647);
session_set_outgoing_window(session, 65536);
AMQP_VALUE source = messaging_create_source("ingress");
AMQP_VALUE target = messaging_create_target("amqps://" EH_HOST "/" EH_NAME);
link = link_create(session, "sender-link", role_sender, source, target);
link_set_snd_settle_mode(link, sender_settle_mode_unsettled);
(void)link_set_max_message_size(link, 65536);
amqpvalue_destroy(source);
amqpvalue_destroy(target);
message = message_create();
unsigned char hello[] = { 'H', 'e', 'l', 'l', 'o' };
BINARY_DATA binary_data;
binary_data.bytes = hello;
binary_data.length = sizeof(hello);
message_add_body_amqp_data(message, binary_data);
/* create a message sender */
message_sender = messagesender_create(link, NULL, NULL);
if (messagesender_open(message_sender) == 0)
{
uint32_t i;
#if _WIN32
unsigned long startTime = (unsigned long)GetTickCount64();
#endif
for (i = 0; i < msg_count; i++)
{
(void)messagesender_send(message_sender, message, on_message_send_complete, message);
}
message_destroy(message);
while (true)
{
size_t current_memory_used;
size_t maximum_memory_used;
connection_dowork(connection);
current_memory_used = amqpalloc_get_current_memory_used();
maximum_memory_used = amqpalloc_get_maximum_memory_used();
if (current_memory_used != last_memory_used)
{
(void)printf("Current memory usage:%lu (max:%lu)\r\n", (unsigned long)current_memory_used, (unsigned long)maximum_memory_used);
last_memory_used = current_memory_used;
}
if (sent_messages == msg_count)
{
break;
}
}
#if _WIN32
unsigned long endTime = (unsigned long)GetTickCount64();
(void)printf("Send %zu messages in %lu ms: %.02f msgs/sec\r\n", msg_count, (endTime - startTime), (float)msg_count / ((float)(endTime - startTime) / 1000));
#endif
}
messagesender_destroy(message_sender);
link_destroy(link);
session_destroy(session);
connection_destroy(connection);
xio_destroy(sasl_io);
xio_destroy(tls_io);
saslmechanism_destroy(sasl_mechanism_handle);
platform_deinit();
(void)printf("Max memory usage:%lu\r\n", (unsigned long)amqpalloc_get_maximum_memory_used());
(void)printf("Current memory usage:%lu\r\n", (unsigned long)amqpalloc_get_current_memory_used());
result = 0;
}
#ifdef _CRTDBG_MAP_ALLOC
_CrtDumpMemoryLeaks();
#endif
return result;
}
int main(int argc, char** argv)
{
int result;
(void)argc, argv;
amqpalloc_set_memory_tracing_enabled(true);
if (platform_init() != 0)
{
result = -1;
}
else
{
CONNECTION_HANDLE connection;
SESSION_HANDLE session;
LINK_HANDLE link;
MESSAGE_SENDER_HANDLE message_sender;
MESSAGE_HANDLE message;
size_t last_memory_used = 0;
/* create socket IO */
XIO_HANDLE socket_io;
SOCKETIO_CONFIG socketio_config = { "localhost", 5672, NULL };
socket_io = xio_create(socketio_get_interface_description(), &socketio_config);
/* create the connection, session and link */
connection = connection_create(socket_io, "localhost", "some", NULL, NULL);
session = session_create(connection, NULL, NULL);
session_set_incoming_window(session, 2147483647);
session_set_outgoing_window(session, 65536);
AMQP_VALUE source = messaging_create_source("ingress");
AMQP_VALUE target = messaging_create_target("localhost/ingress");
link = link_create(session, "sender-link", role_sender, source, target);
link_set_snd_settle_mode(link, sender_settle_mode_settled);
(void)link_set_max_message_size(link, 65536);
amqpvalue_destroy(source);
amqpvalue_destroy(target);
message = message_create();
unsigned char hello[] = { 'H', 'e', 'l', 'l', 'o' };
BINARY_DATA binary_data;
binary_data.bytes = hello;
binary_data.length = sizeof(hello);
message_add_body_amqp_data(message, binary_data);
/* create a message sender */
message_sender = messagesender_create(link, NULL, NULL);
if (messagesender_open(message_sender) == 0)
{
uint32_t i;
#if _WIN32
unsigned long startTime = (unsigned long)GetTickCount64();
#endif
for (i = 0; i < msg_count; i++)
{
(void)messagesender_send(message_sender, message, on_message_send_complete, message);
}
message_destroy(message);
while (true)
{
size_t current_memory_used;
size_t maximum_memory_used;
connection_dowork(connection);
current_memory_used = amqpalloc_get_current_memory_used();
maximum_memory_used = amqpalloc_get_maximum_memory_used();
if (current_memory_used != last_memory_used)
{
(void)printf("Current memory usage:%lu (max:%lu)\r\n", (unsigned long)current_memory_used, (unsigned long)maximum_memory_used);
last_memory_used = current_memory_used;
}
if (sent_messages == msg_count)
{
break;
}
}
#if _WIN32
unsigned long endTime = (unsigned long)GetTickCount64();
(void)printf("Send %zu messages in %lu ms: %.02f msgs/sec\r\n", msg_count, (endTime - startTime), (float)msg_count / ((float)(endTime - startTime) / 1000));
#endif
}
messagesender_destroy(message_sender);
link_destroy(link);
session_destroy(session);
connection_destroy(connection);
xio_destroy(socket_io);
platform_deinit();
(void)printf("Max memory usage:%lu\r\n", (unsigned long)amqpalloc_get_maximum_memory_used());
(void)printf("Current memory usage:%lu\r\n", (unsigned long)amqpalloc_get_current_memory_used());
result = 0;
}
#ifdef _CRTDBG_MAP_ALLOC
_CrtDumpMemoryLeaks();
#endif
return result;
}