自学教程：C++ AJ_ErrPrintf函数代码示例

AJ_Status AJ_Net_Connect(AJ_NetSocket* netSock, uint16_t port, uint8_t addrType, const uint32_t* addr){    int ret;    IPAddress ip(*addr);    AJ_InfoPrintf(("AJ_Net_Connect(nexSock=0x%p, port=%d., addrType=%d., addr=0x%p)/n", netSock, port, addrType, addr));    AJ_InfoPrintf(("AJ_Net_Connect(): Connect to 0x%x:%u./n", addr, port));;    ret = g_client.connect(ip, port);#ifdef NOTDEF    Serial.print("Connecting to: ");    Serial.print(ip);    Serial.print(':');    Serial.println(port);#endif    if (ret == -1) {        AJ_ErrPrintf(("AJ_Net_Connect(): connect() failed: %d: status=AJ_ERR_CONNECT/n", ret));        return AJ_ERR_CONNECT;    } else {        AJ_IOBufInit(&netSock->rx, rxData, sizeof(rxData), AJ_IO_BUF_RX, (void*)&g_client);        netSock->rx.recv = AJ_Net_Recv;        AJ_IOBufInit(&netSock->tx, txData, sizeof(txData), AJ_IO_BUF_TX, (void*)&g_client);        netSock->tx.send = AJ_Net_Send;        AJ_ErrPrintf(("AJ_Net_Connect(): connect() success: status=AJ_OK/n"));        return AJ_OK;    }    AJ_ErrPrintf(("AJ_Net_Connect(): connect() failed: %d: status=AJ_ERR_CONNECT/n", ret));    return AJ_ERR_CONNECT;}

static AJ_Status MatchProp(const char* member, const char* prop, uint8_t op, const char** sig){    const char* encoding = member;    if (*encoding++ != '@') {        AJ_ErrPrintf(("MatchProp(): AJ_ERR_NO_MATCH/n"));        return AJ_ERR_NO_MATCH;    }    while (*prop) {        if (*encoding++ != *prop++) {            AJ_ErrPrintf(("MatchProp(): AJ_ERR_NO_MATCH/n"));            return AJ_ERR_NO_MATCH;        }    }    if ((op == AJ_PROP_GET) && (*encoding == WRITE_ONLY)) {        AJ_ErrPrintf(("MatchProp(): AJ_ERR_DISALLOWED/n"));        return AJ_ERR_DISALLOWED;    }    if ((op == AJ_PROP_SET) && (*encoding == READ_ONLY)) {        AJ_ErrPrintf(("MatchProp(): AJ_ERR_DISALLOWED/n"));        return AJ_ERR_DISALLOWED;    }    *sig = ++encoding;    return AJ_OK;}

static AJ_Status ExportIfNeeded(const char* dev, int deviceId, const char* root){    int fd;    DIR* dir;    char buf[256];    snprintf(buf, sizeof(buf), "%s%s", root, dev);    dir = opendir(buf);    if (dir) {        closedir(dir);        return AJ_OK;    }    if (errno != ENOENT) {        AJ_ErrPrintf(("Failed opendir %d %s/n", errno, buf));        return AJ_ERR_INVALID;    }    /*     * Try to create the device entry     */    snprintf(buf, sizeof(buf), "%s%s", root, "export");    fd = open(buf, O_WRONLY);    if (fd >= 0) {        size_t sz = snprintf(buf, sizeof(buf), "%d", deviceId);        write(fd, buf, sz + 1);        close(fd);        return AJ_OK;    } else {        AJ_ErrPrintf(("Failed to open %s/n", buf));        return AJ_ERR_INVALID;    }}

static AJ_Status AJ_ARDP_UDP_Send(void* context, uint8_t* buf, size_t len, size_t* sent){    AJ_Status status = AJ_OK;    DWORD ret;    NetContext* ctx = (NetContext*) context;    WSAOVERLAPPED ov;    DWORD flags = 0;    WSABUF wsbuf;    memset(&ov, 0, sizeof(ov));    ov.hEvent = sendEvent;    wsbuf.len = len;    wsbuf.buf = buf;    AJ_InfoPrintf(("AJ_ARDP_UDP_Send(buf=0x%p, len=%lu)/n", buf, len));    ret = WSASend(ctx->udpSock, &wsbuf, 1, NULL, flags, &ov, NULL);    if (ret == SOCKET_ERROR) {        AJ_ErrPrintf(("AJ_ARDP_UDP_Send(): WSASend() failed. WSAGetLastError()=0x%x, status=AJ_ERR_WRITE/n", WSAGetLastError()));        *sent = 0;        return AJ_ERR_WRITE;    }    if (!WSAGetOverlappedResult(ctx->udpSock, &ov, sent, TRUE, &flags)) {        AJ_ErrPrintf(("AJ_ARDP_UDP_Send(): WSAGetOverlappedResult() failed. WSAGetLastError()=0x%x, status=AJ_ERR_WRITE/n", WSAGetLastError()));        return AJ_ERR_WRITE;    }    return status;}

AJ_Status AJNS_Producer_CancelNotification(AJ_BusAttachment* busAttachment, uint32_t serialNum){    AJ_Status status;    uint16_t messageType = 0;    AJ_InfoPrintf(("In CancelNotificationBySerialNum/n"));    if (serialNum == 0) {        AJ_ErrPrintf(("Could not cancel Message - no message to cancel/n"));        return AJ_OK;    }    for (; messageType < AJNS_NUM_MESSAGE_TYPES; messageType++) {        if (lastSentNotifications[messageType].serialNum == serialNum) {            break;        }    }    if (messageType >= AJNS_NUM_MESSAGE_TYPES) {        AJ_ErrPrintf(("Could not find matching Message serial number - no message to cancel/n"));        return AJ_OK;    }    status = AJ_BusCancelSessionless(busAttachment, serialNum);    if (status != AJ_OK) {        AJ_ErrPrintf(("Failed to send cancelation/n"));        return status;    }    AJ_InfoPrintf(("***************** Message with Notification id %d and serialNum %u deleted successfully *****************/n", lastSentNotifications[messageType].notificationId, lastSentNotifications[messageType].serialNum));    lastSentNotifications[messageType].notificationId = 0;    lastSentNotifications[messageType].serialNum = 0;    return status;}

AJ_Status AJNS_Producer_DeleteLastNotification(AJ_BusAttachment* busAttachment, uint16_t messageType){    AJ_Status status;    uint32_t lastSentSerialNumber;   // AJ_InfoPrintf(("In DeleteLastNotification/n"));    if (messageType >= AJNS_NUM_MESSAGE_TYPES) 	{        AJ_ErrPrintf(("Could not delete Notification - MessageType is not valid/n"));        return AJ_ERR_DISALLOWED;    }    lastSentSerialNumber = lastSentNotifications[messageType].serialNum;    if (lastSentSerialNumber == 0) 	{        AJ_ErrPrintf(("Could not Delete Message - no message to delete/n"));        return AJ_OK;    }    status = AJ_BusCancelSessionless(busAttachment, lastSentSerialNumber);    if (status != AJ_OK) 	{        AJ_ErrPrintf(("Could not Delete Message/n"));        return status;    }  //  AJ_InfoPrintf(("***************** Message with Notification id %d and serialNum %u deleted successfully *****************/n", lastSentNotifications[messageType].notificationId, lastSentNotifications[messageType].serialNum));    lastSentNotifications[messageType].notificationId = 0;    lastSentNotifications[messageType].serialNum = 0;    return status;}

AJ_Status CPS_StartService(AJ_BusAttachment* bus, const char* busAddress, uint32_t timeout, uint8_t connected){    AJ_Status status = AJ_OK;    while (TRUE) {        AJ_InfoPrintf(("Attempting to connect to bus '%s'/n", busAddress));        status = AJ_Connect(bus, busAddress, timeout);        if (status != AJ_OK) {            AJ_ErrPrintf(("Failed to connect to bus '%s', sleeping for %d seconds.../n", busAddress, CPSC_CONNECT_PAUSE / 1000));            AJ_Sleep(CPSC_CONNECT_PAUSE);            continue;        }        AJ_InfoPrintf(("Connected successfully/n"));        isBusConnected = TRUE;        status = AJ_BusSetSignalRule(bus, CPSAnnounceMatch, AJ_BUS_SIGNAL_ALLOW);        if (status != AJ_OK) {            AJ_ErrPrintf(("Could not set Announcement Interface AddMatch/n"));            return status;        }        break;    }    ;    return status;}

AJ_Status AJNS_Consumer_SendDismissRequest(AJ_BusAttachment* busAttachment, uint16_t version, int32_t notificationId, const char* appId, const char* senderName, uint32_t sessionId){    AJ_Status status = AJ_OK;    if ((status == AJ_OK) && (sessionId != 0)) {        AJ_Message dismissMsg;        status = AJ_MarshalMethodCall(busAttachment, &dismissMsg, NOTIFICATION_PRODUCER_DISMISS_PROXY, senderName, sessionId, AJ_NO_FLAGS, AJ_CALL_TIMEOUT);        if (status != AJ_OK) {            AJ_ErrPrintf(("Could not marshal method call/n"));            return status;        }        status = AJ_MarshalArgs(&dismissMsg, "i", notificationId);        if (status != AJ_OK) {            AJ_ErrPrintf(("Could not marshal arguments/n"));            return status;        }        status = AJ_DeliverMsg(&dismissMsg);        if (status != AJ_OK) {            AJ_ErrPrintf(("Could not deliver message/n"));            return status;        }        AJ_CloseMsg(&dismissMsg);    }    return status;}

AJ_Status AJ_Net_Connect(AJ_BusAttachment* bus, const AJ_Service* service){    int ret;    IPAddress ip(service->ipv4);    if (!(service->addrTypes & AJ_ADDR_TCP4)) {        AJ_ErrPrintf(("AJ_Net_Connect(): only IPV4 TCP supported/n", ret));        return AJ_ERR_CONNECT;    }    AJ_InfoPrintf(("AJ_Net_Connect(bus=0x%p, addrType=%d.)/n", bus, service->addrTypes));    ret = g_client.connect(ip, service->ipv4port);    if (ret != 1) {        AJ_ErrPrintf(("AJ_Net_Connect(): connect() failed: %d: status=AJ_ERR_CONNECT/n", ret));        return AJ_ERR_CONNECT;    } else {        AJ_IOBufInit(&bus->sock.rx, rxData, sizeof(rxData), AJ_IO_BUF_RX, (void*)&g_client);        bus->sock.rx.recv = AJ_Net_Recv;        AJ_IOBufInit(&bus->sock.tx, txData, sizeof(txData), AJ_IO_BUF_TX, (void*)&g_client);        bus->sock.tx.send = AJ_Net_Send;        AJ_ErrPrintf(("AJ_Net_Connect(): connect() success: status=AJ_OK/n"));        return AJ_OK;    }    AJ_ErrPrintf(("AJ_Net_Connect(): connect() failed: %d: status=AJ_ERR_CONNECT/n", ret));    return AJ_ERR_CONNECT;}

static void OpenSimIO(){    pthread_attr_t attr;    struct sockaddr_un sa;    memset(&sa, 0, sizeof(sa));    sa.sun_family = AF_UNIX;    memcpy(sa.sun_path, gui_server, sizeof(gui_server));    sock = socket(AF_UNIX,  SOCK_STREAM, 0);    if (sock >= 0) {        pthread_t threadId;        int ret = connect(sock, (struct sockaddr*)&sa, sizeof(sa));        if (ret == -1) {            AJ_ErrPrintf(("Failed to connect to I/O gui server/n"));            close(sock);            sock = -1;        }        /*         * Create thread to handle reads         */        pthread_attr_init(&attr);        ret = pthread_create(&threadId, NULL, SockRead, NULL);        if (ret) {            AJ_ErrPrintf(("Failed to create read thread/n"));            close(sock);            sock = -1;        } else {            pthread_detach(threadId);            pthread_cond_init(&cond, NULL);            pthread_mutex_init(&mutex, NULL);        }    }}

static AJ_Status AJ_ARDP_UDP_Recv(void* context, uint8_t** data, uint32_t* recved, uint32_t timeout){    NetContext* ctx = (NetContext*) context;    DWORD ret = SOCKET_ERROR;    WSAEVENT events[2];    DWORD flags = 0;    static uint8_t buffer[UDP_SEGBMAX];    *data = NULL;    if (wsaOverlapped.hEvent == INVALID_HANDLE_VALUE) {        wsbuf.len = sizeof(buffer);        wsbuf.buf = buffer;        memset(&wsaOverlapped, 0, sizeof(WSAOVERLAPPED));        wsaOverlapped.hEvent = recvEvent;        ret = WSARecvFrom(ctx->udpSock, &wsbuf, 1, NULL, &flags, NULL, NULL, &wsaOverlapped, NULL);        if ((ret == SOCKET_ERROR) && (WSAGetLastError() != WSA_IO_PENDING)) {            AJ_ErrPrintf(("WSARecvFrom(): failed WSAGetLastError()=%d/n", WSAGetLastError()));            return AJ_ERR_READ;        }    }    events[0] = wsaOverlapped.hEvent;    events[1] = interruptEvent;    ret = WSAWaitForMultipleEvents(2, events, FALSE, timeout, TRUE);    switch (ret) {    case WSA_WAIT_EVENT_0:        flags = 0;        if (WSAGetOverlappedResult(ctx->udpSock, &wsaOverlapped, recved, TRUE, &flags)) {            WSAResetEvent(wsaOverlapped.hEvent);            wsaOverlapped.hEvent = INVALID_HANDLE_VALUE;            *data = buffer;            return AJ_OK;        } else {            AJ_ErrPrintf(("AJ_ARDP_UDP_Recv(): WSAGetOverlappedResult error; WSAGetLastError()=%d/n", WSAGetLastError()));            return AJ_ERR_READ;        }        break;    case WSA_WAIT_EVENT_0 + 1:        WSAResetEvent(interruptEvent);        return AJ_ERR_INTERRUPTED;    case WSA_WAIT_TIMEOUT:        return AJ_ERR_TIMEOUT;        break;    default:        AJ_ErrPrintf(("AJ_ARDP_UDP_Recv(): WSAWaitForMultipleEvents error; WSAGetLastError()=%d/n", WSAGetLastError()));        return AJ_ERR_READ;    }}

AJ_Status AJNS_Producer_ConnectedHandler(AJ_BusAttachment* busAttachment){    AJ_Status status;    AJ_SessionOpts sessionOpts = {        AJ_SESSION_TRAFFIC_MESSAGES,        AJ_SESSION_PROXIMITY_ANY,        AJ_TRANSPORT_ANY,        FALSE    };    uint8_t serviceStarted;    AJ_Message msg;    status = AJ_BusBindSessionPort(busAttachment, AJNS_NotificationProducerPort, &sessionOpts, 0);    if (status != AJ_OK) {        AJ_ErrPrintf(("Failed to send bind session port message/n"));    }    serviceStarted = FALSE;    while (!serviceStarted && (status == AJ_OK)) {        status = AJ_UnmarshalMsg(busAttachment, &msg, AJ_UNMARSHAL_TIMEOUT);        if (status == AJ_ERR_NO_MATCH) {            status = AJ_OK;            continue;        } else if (status != AJ_OK) {            break;        }        switch (msg.msgId) {        case AJ_REPLY_ID(AJ_METHOD_BIND_SESSION_PORT):            if (msg.hdr->msgType == AJ_MSG_ERROR) {                status = AJ_ERR_FAILURE;            } else {                serviceStarted = TRUE;            }            break;        default:            /*             * Pass to the built-in bus message handlers             */            status = AJ_BusHandleBusMessage(&msg);            break;        }        AJ_CloseMsg(&msg);    }    if (status != AJ_OK) {        AJ_ErrPrintf(("AllJoyn disconnect bus status=%d/n", status));        status = AJ_ERR_READ;    }    return status;}

AJ_Status AJ_BusLinkStateProc(AJ_BusAttachment* bus){    AJ_Status status = AJ_OK;    if (bus->isProbeRequired && busLinkTimeout) 	{        if (!busLinkWatcher.linkTimerInited) 		{            busLinkWatcher.linkTimerInited = TRUE;            AJ_InitTimer(&(busLinkWatcher.linkTimer));        }		else		{            uint32_t eclipse = AJ_GetElapsedTime(&(busLinkWatcher.linkTimer), TRUE);            if (eclipse >= busLinkTimeout) 			{                if (!busLinkWatcher.pingTimerInited) 				{                    busLinkWatcher.pingTimerInited = TRUE;                    AJ_InitTimer(&(busLinkWatcher.pingTimer));                    if (AJ_OK != AJ_SendLinkProbeReq(bus)) 					{                        AJ_ErrPrintf(("AJ_BusLinkStateProc(): AJ_SendLinkProbeReq() failure"));                    }                } 				else				{                    eclipse = AJ_GetElapsedTime(&(busLinkWatcher.pingTimer), TRUE);                    if (eclipse >=  AJ_BUS_LINK_PING_TIMEOUT) 					{                        if (++busLinkWatcher.numOfPingTimedOut < AJ_MAX_LINK_PING_PACKETS) 						{                            AJ_InitTimer(&(busLinkWatcher.pingTimer));                            if (AJ_OK != AJ_SendLinkProbeReq(bus)) 							{                                AJ_ErrPrintf(("AJ_BusLinkStateProc(): AJ_SendLinkProbeReq() failure"));                            }                        } 						else						{                            AJ_ErrPrintf(("AJ_BusLinkStateProc(): AJ_ERR_LINK_TIMEOUT"));                            status = AJ_ERR_LINK_TIMEOUT;                            // stop sending probe messages until next link timeout event                            memset(&busLinkWatcher, 0, sizeof(AJ_BusLinkWatcher));                        }                    }                }            }        }    }    return status;}

/* * Implements AES-CCM (Counter with CBC-MAC) decryption as described in RFC 3610 */AJ_Status AJ_Decrypt_CCM(const uint8_t* key,                         uint8_t* msg,                         uint32_t msgLen,                         uint32_t hdrLen,                         uint8_t tagLen,                         const uint8_t* nonce,                         uint32_t nLen){    AJ_Status status = AJ_OK;    CCM_Context* context;    if (!(context = InitCCMContext(nonce, nLen, hdrLen, msgLen, tagLen))) {        AJ_ErrPrintf(("AJ_Decrypt_CCM(): AJ_ERR_RESOURCES/n"));        return AJ_ERR_RESOURCES;    }    /*     * Do any platform specific operations to enable AES     */    AJ_AES_Enable(key);    /*     * Decrypt the authentication field     */    AJ_AES_CTR_128(key, msg + msgLen, msg + msgLen, tagLen, context->ivec.data);    /*     * Decrypt message.     */    if (msgLen != hdrLen) {        AJ_AES_CTR_128(key, msg + hdrLen, msg + hdrLen, msgLen - hdrLen, context->ivec.data);    }    /*     * Compute and verify the authentication tag T.     */    Compute_CCM_AuthTag(key, context, msg, msgLen - hdrLen, hdrLen);    /*     * Balance the enable call above     */    AJ_AES_Disable();    if (AJ_Crypto_Compare(context->T.data, msg + msgLen, tagLen) != 0) {        /*         * Authentication failed Clear the decrypted data         */        memset(msg, 0, msgLen + tagLen);        AJ_ErrPrintf(("AJ_Decrypt_CCM(): AJ_ERR_SECURITY/n"));        status = AJ_ERR_SECURITY;    }    /*     * Done with the context     */    AJ_Free(context);    return status;}

static AJ_Status AJ_Net_Send(AJ_IOBuffer* buf){    DWORD ret;    DWORD tx = AJ_IO_BUF_AVAIL(buf);    AJ_InfoPrintf(("AJ_Net_Send(buf=0x%p)/n", buf));    assert(buf->direction == AJ_IO_BUF_TX);    if (tx > 0) {        NetContext* ctx = (NetContext*) buf->context;        WSAOVERLAPPED ov;        DWORD flags = 0;        WSABUF wsbuf;        memset(&ov, 0, sizeof(ov));        ov.hEvent = sendEvent;        wsbuf.len = tx;        wsbuf.buf = buf->readPtr;        ret = WSASend(ctx->tcpSock, &wsbuf, 1, NULL, flags, &ov, NULL);        if (!WSAGetOverlappedResult(ctx->tcpSock, &ov, &tx, TRUE, &flags)) {            AJ_ErrPrintf(("AJ_Net_Send(): send() failed. WSAGetLastError()=0x%x, status=AJ_ERR_WRITE/n", WSAGetLastError()));            return AJ_ERR_WRITE;        }        buf->readPtr += tx;    }    if (AJ_IO_BUF_AVAIL(buf) == 0) {        AJ_IO_BUF_RESET(buf);    }    AJ_InfoPrintf(("AJ_Net_Send(): status=AJ_OK/n"));    return AJ_OK;}

/** * Since the routing node expects any of its clients to use SASL with Anonymous * or PINX in order to connect, this method will send the necessary SASL * Anonymous exchange in order to connect.  PINX is no longer supported on the * Thin Client.  All thin clients will connect as untrusted clients to the * routing node. */static AJ_Status AnonymousAuthAdvance(AJ_IOBuffer* rxBuf, AJ_IOBuffer* txBuf){    AJ_Status status = AJ_OK;    AJ_GUID localGuid;    char buf[40];    /* initiate the SASL exchange with AUTH ANONYMOUS */    status = WriteLine(txBuf, "AUTH ANONYMOUS/n");    ResetRead(rxBuf);    if (status == AJ_OK) {        /* expect server to send back OK GUID */        status = ReadLine(rxBuf);        if (status == AJ_OK) {            if (memcmp(rxBuf->readPtr, "OK", 2) != 0) {                return AJ_ERR_ACCESS_ROUTING_NODE;            }        }    }    if (status == AJ_OK) {        status = WriteLine(txBuf, "INFORM_PROTO_VERSION 10/n");        ResetRead(rxBuf);    }    if (status == AJ_OK) {        /* expect server to send back INFORM_PROTO_VERSION version# */        status = ReadLine(rxBuf);    }    if (status == AJ_OK) {        if (memcmp(rxBuf->readPtr, "INFORM_PROTO_VERSION", strlen("INFORM_PROTO_VERSION")) != 0) {            status = AJ_ERR_ACCESS_ROUTING_NODE;        }    }    if (status == AJ_OK) {        routingProtoVersion = atoi((const char*)(rxBuf->readPtr + strlen("INFORM_PROTO_VERSION") + 1));        if (routingProtoVersion < AJ_GetMinProtoVersion()) {            AJ_InfoPrintf(("AnonymousAuthAdvance():: Found version %u but minimum %u required", routingProtoVersion, AJ_GetMinProtoVersion()));            status = AJ_ERR_OLD_VERSION;        }    }    if (status == AJ_OK) {        /* send BEGIN LocalGUID to server */        AJ_GetLocalGUID(&localGuid);        strcpy(buf, "BEGIN ");        status = AJ_GUID_ToString(&localGuid, buf + strlen(buf), 33);        strcat(buf, "/n");        status = WriteLine(txBuf, buf);        ResetRead(rxBuf);    }    if (status != AJ_OK) {        AJ_ErrPrintf(("AnonymousAuthAdvance(): status=%s/n", AJ_StatusText(status)));    }    return status;}

AJ_Status AJS_TargetIO_PinEnableTrigger(void* pinCtx, AJS_IO_PinTriggerMode trigger, int32_t* trigId, uint8_t debounce){    GPIO* gpio = (GPIO*)pinCtx;    if ((trigger != AJS_IO_PIN_TRIGGER_ON_RISE) && (trigger != AJS_IO_PIN_TRIGGER_ON_FALL)) {        /*         * Disable triggers for this pin         */        if (gpio->trigId != AJS_IO_PIN_NO_TRIGGER) {            SendCmd('i', gpio, 0, 0);            *trigId = gpio->trigId;            BIT_CLR(trigSet, gpio->trigId);            gpio->trigId = AJS_IO_PIN_NO_TRIGGER;        } else {            *trigId = AJS_IO_PIN_NO_TRIGGER;        }        return AJ_OK;    }    SendCmd('i', gpio, (trigger == AJS_IO_PIN_TRIGGER_ON_RISE) ? 1 : 2, 0);    gpio->trigId = gpio->pinId;    *trigId = gpio->trigId;    AJ_ErrPrintf(("AJS_TargetIO_PinEnableTrigger pinId %d/n", gpio->pinId));    return AJ_OK;}

static void* SockRead(void* arg){    while (sock != -1) {        uint8_t buf[3];        int ret = recv(sock, buf, sizeof(buf), MSG_WAITALL);        if (ret != 3) {            AJ_ErrPrintf(("Recv failed - closing socket/n"));            close(sock);            sock = -1;            break;        }        if (buf[0] == 'r') {            memcpy(recvBuf, buf, ret);            pthread_mutex_lock(&mutex);            pthread_cond_signal(&cond);            pthread_mutex_unlock(&mutex);        } else if (buf[0] == 'i') {            /*             * Record which trigger fired             */            BIT_SET(trigSet, buf[1] - 1);            AJ_Net_Interrupt();        }    }    pthread_cond_destroy(&cond);    pthread_mutex_destroy(&mutex);    return NULL;}

void AJS_TargetIO_PinSet(void* pinCtx, uint32_t val){    GPIO* gpio = (GPIO*)pinCtx;    if (!SendCmd('w', gpio, (uint8_t)val, 0)) {        AJ_ErrPrintf(("AJS_TargetIO_PinSet(%d, %d)/n", gpio->pinId, val));    }}

/* * Check that the signature in the message matches the encoded signature in the string */static AJ_Status CheckSignature(const char* encoding, const AJ_Message* msg){    const char* sig = msg->signature ? msg->signature : "";    char direction = (msg->hdr->msgType == AJ_MSG_METHOD_CALL) ? IN_ARG : OUT_ARG;    /*     * Wild card in the message is ok.     */    if (*sig == '*') {        return AJ_OK;    }    while (*encoding) {        /*         * Skip until we find a direction character         */        while (*encoding && (*encoding++ != direction)) {        }        /*         * Match a single arg to the signature         */        while (*encoding && (*sig == *encoding)) {            ++sig;            ++encoding;        }        if (*encoding && (*encoding != ' ')) {            AJ_ErrPrintf(("CheckSignature(): AJ_ERR_SIGNATURE/n"));            return AJ_ERR_SIGNATURE;        }    }    /*     * On a match we should have consumed both strings     */    return (*encoding == *sig) ? AJ_OK : AJ_ERR_SIGNATURE;}

static uint8_t AJRouter_Connect(AJ_BusAttachment* busAttachment, const char* routerName){    AJ_Status status;    const char* busUniqueName;    while (TRUE) {        AJ_InfoPrintf(("Attempting to connect to bus '%s'/n", routerName));        status = AJ_FindBusAndConnect(busAttachment, routerName, AJAPP_CONNECT_TIMEOUT);        if (status != AJ_OK) {            AJ_InfoPrintf(("Failed to connect to bus sleeping for %d seconds/n", AJAPP_CONNECT_PAUSE / 1000));            AJ_Sleep(AJAPP_CONNECT_PAUSE);            continue;        }        busUniqueName = AJ_GetUniqueName(busAttachment);        if (busUniqueName == NULL) {            AJ_ErrPrintf(("Failed to GetUniqueName() from newly connected bus, retrying/n"));            continue;        }        AJ_InfoPrintf(("Connected to router with BusUniqueName=%s/n", busUniqueName));        break;    }    /* Setup password based authentication listener for secured peer to peer connections */    AJ_BusSetPasswordCallback(busAttachment, PasswordCallback);    /* Configure timeout for the link to the Router bus */    AJ_SetBusLinkTimeout(busAttachment, 60);     // 60 seconds    return TRUE;}

AJ_Status AJ_GUID_HandleAddMatchReply(AJ_Message* msg){    AJ_Status status;    NameToGUID* mapping;    uint32_t serialNum = 0;  //  AJ_InfoPrintf(("AJ_GUID_HandleAddMatchReply(msg=0x%p)/n", msg));    mapping = LookupReplySerial(msg->replySerial);    if (!mapping) 	{        return AJ_OK;    }    mapping->replySerial = 0;    if (msg->hdr->msgType == AJ_MSG_ERROR) 	{        AJ_ErrPrintf(("AJ_GUID_HandleAddMatchReply(msg=0x%p): error=%s./n", msg, msg->error));        AJ_GUID_DeleteNameMapping(msg->bus, mapping->uniqueName);        return AJ_ERR_FAILURE;    }    // Add match complete.   // AJ_InfoPrintf(("Add match Complete/n"));    status = NameHasOwner(msg, mapping->uniqueName, &serialNum);    if (status == AJ_OK) 	{        mapping->replySerial = serialNum;    } 	else 	{        AJ_GUID_DeleteNameMapping(msg->bus, mapping->uniqueName);    }    return status;}

AJ_Status AJ_Net_MCastUp(AJ_MCastSocket* mcastSock){    uint8_t ret = 0;    AJ_InfoPrintf(("AJ_Net_MCastUp(mcastSock=0x%p)/n", mcastSock));    //    // Arduino does not choose an ephemeral port if we enter 0 -- it happily    // uses 0 and then increments each time we bind, up through the well-known    // system ports.    //    ret = g_clientUDP.begin(AJ_EphemeralPort());    if (ret != 1) {        g_clientUDP.stop();        AJ_ErrPrintf(("AJ_Net_MCastUp(): begin() fails. status=AJ_ERR_READ/n"));        return AJ_ERR_READ;    } else {        AJ_IOBufInit(&mcastSock->rx, rxData, sizeof(rxData), AJ_IO_BUF_RX, (void*)&g_clientUDP);        mcastSock->rx.recv = AJ_Net_RecvFrom;        AJ_IOBufInit(&mcastSock->tx, txData, sizeof(txData), AJ_IO_BUF_TX, (void*)&g_clientUDP);        mcastSock->tx.send = AJ_Net_SendTo;    }    AJ_InfoPrintf(("AJ_Net_MCastUp(): status=AJ_OK/n"));    return AJ_OK;}

void EXTI9_5_IRQHandler(void){    if (EXTI_GetITStatus(EXTI_Line5) != RESET) {        //Handle the interrupt        AJ_Printf("EXTI5_IRQHandler/n");        EXTI_ClearITPendingBit(EXTI_Line5);        EXTI_ClearFlag(EXTI_Line5);    } else if (EXTI_GetITStatus(EXTI_Line6) != RESET) {        AJ_Printf("EXTI6_IRQHandler/n");        EXTI_ClearITPendingBit(EXTI_Line6);        EXTI_ClearFlag(EXTI_Line6);    } else if (EXTI_GetITStatus(EXTI_Line7) != RESET) {        AJ_Printf("EXTI7_IRQHandler/n");        EXTI_ClearITPendingBit(EXTI_Line7);        EXTI_ClearFlag(EXTI_Line7);    } else if (EXTI_GetITStatus(EXTI_Line8) != RESET) {        AJ_Printf("EXTI8_IRQHandler/n");        EXTI_ClearITPendingBit(EXTI_Line8);        EXTI_ClearFlag(EXTI_Line8);    } else if (EXTI_GetITStatus(EXTI_Line9) != RESET) {        AJ_Printf("EXTI9_IRQHandler/n");        EXTI_ClearITPendingBit(EXTI_Line9);        EXTI_ClearFlag(EXTI_Line9);    } else {        AJ_ErrPrintf(("EXTI9_5_IRQHandler(): IRQ Error/n"));    }}

/** * Send notify signal */static AJ_Status AJNS_Producer_SendNotifySignal(AJ_BusAttachment* busAttachment, AJNS_Notification* notification, uint32_t ttl, uint32_t* messageSerialNumber){    AJ_Status status;    AJ_Message msg;    uint32_t serialNum;//    AJ_InfoPrintf(("In SendNotifySignal/n"));    status = AJNS_Producer_MarshalNotificationMsg(busAttachment, &msg, notification, ttl);    if (status != AJ_OK) 	{ //       AJ_InfoPrintf(("Could not Marshal Message/n"));        return status;    }    serialNum = msg.hdr->serialNum;    status = AJ_DeliverMsg(&msg);    if (status != AJ_OK) 	{        AJ_ErrPrintf(("Could not Deliver Message/n"));        return status;    } //   AJ_InfoPrintf(("***************** Notification id %d delivered successfully with serial number %u *****************/n", notification->notificationId, serialNum));    if (messageSerialNumber != NULL)	{        *messageSerialNumber = serialNum;    }    AJ_CloseMsg(&msg);    return status;}

void EXTI15_10_IRQHandler(void){    if (EXTI_GetITStatus(EXTI_Line10) != RESET) {        //Handle the interrupt        AJ_Printf("EXTI10_IRQHandler/n");        EXTI_ClearITPendingBit(EXTI_Line10);        EXTI_ClearFlag(EXTI_Line10);    } else if (EXTI_GetITStatus(EXTI_Line11) != RESET) {        AJ_Printf("EXTI11_IRQHandler/n");        EXTI_ClearITPendingBit(EXTI_Line11);        EXTI_ClearFlag(EXTI_Line11);    } else if (EXTI_GetITStatus(EXTI_Line12) != RESET) {        AJ_Printf("EXTI12_IRQHandler/n");        EXTI_ClearITPendingBit(EXTI_Line12);        EXTI_ClearFlag(EXTI_Line12);    } else if (EXTI_GetITStatus(EXTI_Line13) != RESET) {        AJ_Printf("EXTI13_IRQHandler/n");        EXTI_ClearITPendingBit(EXTI_Line13);        EXTI_ClearFlag(EXTI_Line13);    } else if (EXTI_GetITStatus(EXTI_Line14) != RESET) {        AJ_Printf("EXTI14_IRQHandler/n");        EXTI_ClearITPendingBit(EXTI_Line14);        EXTI_ClearFlag(EXTI_Line14);    } else if (EXTI_GetITStatus(EXTI_Line15) != RESET) {        AJ_Printf("EXTI15_IRQHandler/n");        EXTI_ClearITPendingBit(EXTI_Line15);        EXTI_ClearFlag(EXTI_Line15);    } else {        AJ_ErrPrintf(("EXTI15_10_IRQHandler(): IRQ Error/n"));    }}

void AJ_WSL_ModuleInit(void){    //prepare the WSL heap    size_t heapSz;    heapSz = AJ_PoolRequired(wsl_heapConfig, ArraySize(wsl_heapConfig));    if (heapSz > sizeof(wsl_heap)) {        AJ_ErrPrintf(("Heap space is too small %d required %d/n", sizeof(wsl_heap), heapSz));        return;    }    AJ_InfoPrintf(("Allocated heap %d bytes/n", (int)heapSz));    AJ_PoolInit(wsl_heap, heapSz, wsl_heapConfig, ArraySize(wsl_heapConfig));    AJ_PoolDump();    AJ_WSL_SOCKNUM i;    for (i = 0; i < AJ_WSL_SOCKET_MAX; i++) {        memset(&AJ_WSL_SOCKET_CONTEXT[i], 0, sizeof(AJ_WSL_SOCKET_CONTEXT[0]));        AJ_WSL_SOCKET_CONTEXT[i].targetHandle = AJ_WSL_SOCKET_HANDLE_INVALID;        AJ_WSL_SOCKET_CONTEXT[i].stashedRxList = AJ_BufListCreate();        AJ_WSL_SOCKET_CONTEXT[i].workRxQueue = AJ_QueueCreate("RxQueue");        AJ_WSL_SOCKET_CONTEXT[i].workTxQueue = AJ_QueueCreate("TxQueue");    }    AJ_WSL_WMI_ModuleInit();}

AJ_Status AJS_TargetIO_PinClose(void* pinCtx){    GPIO* gpio = (GPIO*)pinCtx;    AJ_ErrPrintf(("AJS_TargetIO_PinClose(%d)/n", gpio->pinId));    free(gpio);    return AJ_OK;}

static AJ_Status ComposeWhoHas(AJ_IOBuffer* txBuf, const char* prefix){    size_t preLen = strlen(prefix);    NSHeader* hdr = (NSHeader*)txBuf->writePtr;    uint8_t* p = txBuf->writePtr + 6;    size_t outLen = (6 + preLen + 2);    AJ_InfoPrintf(("ComposeWhoHas(txbuf=0x%p, prefix=/"%s/")/n", txBuf, prefix));    if (outLen > AJ_IO_BUF_SPACE(txBuf)) {        AJ_ErrPrintf(("ComposeWhoHas(): AJ_ERR_RESOURCES/n"));        return AJ_ERR_RESOURCES;    }    hdr->version = MSG_V1 | NSV_V1;    hdr->qCount = 1;    hdr->aCount = 0;    hdr->ttl = 0;    hdr->flags = WHO_HAS_MSG;    hdr->nameCount = 1;    *p++ = (uint8_t)(preLen + 1);    memcpy(p, prefix, preLen);    /*     * Tack wild-card onto the end of the name to indicate it's prefix     */    p[preLen] = '*';    txBuf->writePtr += outLen;    return AJ_OK;}

void AJS_TargetIO_PinToggle(void* pinCtx){    GPIO* gpio = (GPIO*)pinCtx;    if (!SendCmd('t', gpio, 0, 0)) {        AJ_ErrPrintf(("AJS_TargetIO_PinToggle(%d)/n", gpio->pinId));    }}