static
int send_msg( char *dest_addr, char *return_addr, NodeMessage *msg )
{
int dest_port, buflen = SENDBUF_LEN;
char *colon, buf[SENDBUF_LEN], dest_host[16];
int sock;
colon = strchr( (const char*)dest_addr, ':' );
if (colon == NULL) {
Dbg_printf( NODE, ERROR, "send_msg, ':' not found in the dest_addr=%s\n", dest_addr );
return -1;
}
memcpy( dest_host, dest_addr, sizeof(char) * (colon - dest_addr) );
dest_host[colon - dest_addr] = '\0';
dest_port = atoi( colon + 1 );
if ((sock = Socket_create()) < 0 ) {
Dbg_printf( NODE, ERROR, "send_msg, socket creation failed\n" );
return -1;
}
node_set_return_addr( msg, return_addr );
if (Socket_connect( sock, dest_host, dest_port ) < 0) {
Dbg_printf( NODE, ERROR, "send_msg, socket connect failed\n" );
return -1;
}
if (node_stringify_msg( msg, buf, &buflen ) < 0 ) {
Dbg_printf( NODE, ERROR, "send_msg, msg stringify failed\n" );
return -1;
}
Socket_send_data( sock, buf, buflen );
Socket_close( sock );
Dbg_printf( NODE, API, "%s message sent to %s\n", node_msgid2str( msg->msgid ), dest_addr );
return 0;
}
extern int Client_init(
Client_T* sock,
int (*request)(
char* request, const char* response, int size)) {
if (Socket_connect(sock) < 0) {
log_err("Socket connect failed: %s", Socket_strerror());
return -1;
}
Socket_timeout(sock, 5);
char request_s[65537];
char response[65537];
int bytes_recv;
int bytes_sent;
int status;
memset(response, 0, sizeof(response));
request(request_s, response, 65537);
do {
log_info("Server: %s:%s",
Socket_get_ip(sock), Socket_get_port(sock));
bytes_sent = Socket_send(sock, request_s, strlen(request_s));
if (bytes_sent == -1)
log_warn("Error at sending request");
bytes_recv = Socket_receive(sock, response, 65537);
if (bytes_recv == -1) {
log_warn("Error at receiving response");
} else {
log_debug("Client received '%.*s'", bytes_recv,
response);
}
status = request(request_s, response, 65537);
} while(status == 0);
return 0;
}
// Try connecting to the next address.
static Socket *
tryConnectHostNext(ConnectState *connectState) {
struct addrinfo *info;
Socket *sock;
int connectResult;
assert(connectState->nd == NULL);
info = connectState->infoPtr;
sock = Socket_openNative(info->ai_family, info->ai_socktype,
info->ai_protocol);
if (sock == Socket_noSocket) {
int savedErrno = errno;
log_add(log_Error, "socket() failed: %s.\n", strerror(errno));
errno = savedErrno;
return Socket_noSocket;
}
if (Socket_setNonBlocking(sock) == -1) {
int savedErrno = errno;
log_add(log_Error, "Could not make socket non-blocking: %s.\n",
strerror(errno));
errno = savedErrno;
return Socket_noSocket;
}
(void) Socket_setReuseAddr(sock);
// Ignore errors; it's not a big deal.
(void) Socket_setInlineOOB(sock);
// Ignore errors; it's not a big deal as the other party is not
// not supposed to send any OOB data.
(void) Socket_setKeepAlive(sock);
// Ignore errors; it's not a big deal.
connectResult = Socket_connect(sock, info->ai_addr, info->ai_addrlen);
if (connectResult == 0) {
// Connection has already succeeded.
// We just wait for the writability callback anyhow, so that
// we can use one code path.
return sock;
}
switch (errno) {
case EINPROGRESS:
// Connection in progress; wait for the write callback.
return sock;
}
// Connection failed immediately. This is just for one of the addresses,
// so this does not have to be final.
// Note that as the socket is non-blocking, most failed connection
// errors will usually not be reported immediately.
{
int savedErrno = errno;
Socket_close(sock);
#ifdef DEBUG
log_add(log_Debug, "connect() immediately failed for one address: "
"%s.\n", strerror(errno));
// TODO: add the address in the status message.
#endif
errno = savedErrno;
}
return Socket_noSocket;
}
void
IsoClientConnection_associate(IsoClientConnection self, IsoConnectionParameters* params,
ByteBuffer* payload)
{
Socket socket = TcpSocket_create();
self->socket = socket;
if (!Socket_connect(socket, params->hostname, params->tcpPort))
goto returnError;
self->cotpBuf = malloc(ISO_CLIENT_BUFFER_SIZE);
self->cotpBuffer = calloc(1, sizeof(ByteBuffer));
ByteBuffer_wrap(self->cotpBuffer, self->cotpBuf, 0, ISO_CLIENT_BUFFER_SIZE);
self->cotpConnection = calloc(1, sizeof(CotpConnection));
CotpConnection_init(self->cotpConnection, socket, self->cotpBuffer);
/* COTP handshake */
CotpIndication cotpIndication =
CotpConnection_sendConnectionRequestMessage(self->cotpConnection);
cotpIndication = CotpConnection_parseIncomingMessage(self->cotpConnection);
if (cotpIndication != CONNECT_INDICATION)
goto returnError;
/* Upper layers handshake */
AcseConnection acse;
ByteBuffer acseBuffer;
ByteBuffer_wrap(&acseBuffer, self->buffer1, 0, ISO_CLIENT_BUFFER_SIZE);
AcseConnection_init(&acse);
if (params != NULL)
AcseConnection_setAuthenticationParameter(&acse, params->acseAuthParameter);
AcseConnection_createAssociateRequestMessage(&acse, &acseBuffer, payload);
ByteBuffer presentationBuffer;
ByteBuffer_wrap(&presentationBuffer, self->buffer2, 0, ISO_CLIENT_BUFFER_SIZE);
self->presentation = calloc(1, sizeof(IsoPresentation));
IsoPresentation_init(self->presentation);
IsoPresentation_createConnectPdu(self->presentation, &presentationBuffer, &acseBuffer);
ByteBuffer sessionBuffer;
ByteBuffer_wrap(&sessionBuffer, self->buffer1, 0, ISO_CLIENT_BUFFER_SIZE);
self->session = calloc(1, sizeof(IsoSession));
IsoSession_init(self->session);
IsoSession_createConnectSpdu(self->session, &sessionBuffer,
ByteBuffer_getSize(&presentationBuffer));
ByteBuffer_append(&sessionBuffer, ByteBuffer_getBuffer(&presentationBuffer),
ByteBuffer_getSize(&presentationBuffer));
CotpConnection_sendDataMessage(self->cotpConnection, &sessionBuffer);
cotpIndication = CotpConnection_parseIncomingMessage(self->cotpConnection);
if (cotpIndication != DATA_INDICATION)
goto returnError;
IsoSessionIndication sessionIndication;
sessionIndication =
IsoSession_parseMessage(self->session, CotpConnection_getPayload(self->cotpConnection));
if (sessionIndication != SESSION_CONNECT) {
if (DEBUG) printf("IsoClientConnection_associate: no session connect indication\n");
goto returnError;
}
IsoPresentationIndication presentationIndication;
presentationIndication =
IsoPresentation_parseAcceptMessage(self->presentation, IsoSession_getUserData(self->session));
if (presentationIndication != PRESENTATION_OK) {
if (DEBUG) printf("IsoClientConnection_associate: no presentation ok indication\n");
goto returnError;
}
AcseIndication acseIndication;
acseIndication = AcseConnection_parseMessage(&acse, &self->presentation->nextPayload);
if (acseIndication != ACSE_ASSOCIATE) {
if (DEBUG) printf("IsoClientConnection_associate: no ACSE_ASSOCIATE indication\n");
goto returnError;
}
ByteBuffer acsePayload; //TODO allocate buffer dynamically???
ByteBuffer_wrap(&acsePayload, acse.userDataBuffer, acse.userDataBufferSize, 1024);
self->callback(ISO_IND_ASSOCIATION_SUCCESS, self->callbackParameter, &acsePayload);
self->state = STATE_ASSOCIATED;
AcseConnection_destroy(&acse);
self->thread = Thread_create(connectionHandlingThread, self, false);
Thread_start(self->thread);
return;
returnError:
self->callback(ISO_IND_ASSOCIATION_FAILED, self->callbackParameter, &acsePayload);
AcseConnection_destroy(&acse);
self->state = STATE_ERROR;
return;
}
int main(int argc, char *argv[])
{
Socket_connect("127.0.0.1", 1883);
Socket_connect("localhost", 1883);
Socket_connect("loadsadsacalhost", 1883);
}
