msgserver.cpp

JDesktop Integration Components （JDIC）

        // save the unfinished message part, if any.
        strcpy(unfinishedMsgBuf, delimiterPtr + strlen(MSG_DELIMITER));

        char token[BUFFER_SIZE] = "\0";
        char* bufferPtr = mRecvBuffer;

        while (bufferPtr != NULL) {
            memset(token, '\0', strlen(token));

            delimiterPtr = strstr(bufferPtr, MSG_DELIMITER);
            if (delimiterPtr == NULL) {
                // no delimiter, return the whole string.
                strcpy(token, bufferPtr);
                bufferPtr = NULL;
            } else { 
                strncpy(token, bufferPtr, delimiterPtr - bufferPtr);
                bufferPtr = delimiterPtr + strlen(MSG_DELIMITER);
            }

            if (token[0] == '@') {
                // this is a special response message.
                int instance, msg, data;
                int i = sscanf(token, "@%d,%d,%d", &instance, &msg, &data);
                if (i == 3) {
                    for (int i = 0; i < MAX_TRIGGER; i++) {
                        if (mTriggers[i].mInstance == instance 
                            && mTriggers[i].mMsg == msg) {
                            *(mTriggers[i].mTrigger) = data;
                            mTriggers[i].mInstance = EMPTY_TRIGGER;
                            break;
                        }
                    }
                }
            }
            else if (token[0] == '*') {
                // this is quit message
                if (mHandler) {
                    mHandler(&token[1]);
                }
                return -1;
            }
            else {
                if (mHandler) {
                    // For each message piece ending with a message delimiter, 
                    // check whether the long message buffer is empty. If not, 
                    // this is the end part of a long message, construct the 
                    // complete, long message.
                    if (!strlen(mLongRecvBuffer)) {
                        mHandler(token);
                    } else {
                        // If the long message buffer is not long enough to hold this end
                        // message piece, alloc more space.
                        if (((int)strlen(mLongRecvBuffer) + (int)strlen(token)) 
                            >= mLongRecvBufferSize) {
                            char *tmpRecvBuffer = mLongRecvBuffer;
                            // one more BUFFER_SIZE space is enough for one msgToken (message).
                            mLongRecvBufferSize += BUFFER_SIZE;
                            mLongRecvBuffer 
                                = new char [mLongRecvBufferSize];
                            memset(mLongRecvBuffer, '\0', mLongRecvBufferSize);
                                
                            delete [] tmpRecvBuffer;
                        }      

                        strcat(mLongRecvBuffer, token);
                        mHandler(mLongRecvBuffer);

                        // Clear the long message buffer.
                        memset(mLongRecvBuffer, '\0', 
                            strlen(mLongRecvBuffer));
                    }
                }
            }
        } // end while{}

        // clear the receiver buffer, all the messages should be handled, 
        // except part of an unfinished message.
        memset(mRecvBuffer, '\0', strlen(mRecvBuffer));

        // restore the unfinished message, if any
        if (strlen(unfinishedMsgBuf)) {
            strcpy(mRecvBuffer, unfinishedMsgBuf);
        }

        // store the unhandled message since the receiver buffer is full.
        if (strlen(buf)) {
            strcat(mRecvBuffer, buf);
        }
    }

    return len;
}

int MsgServer::SendData()
{   
    int len = strlen(mSendBuffer);
    if (len == 0)
        return 0;

    len = send(mMsgSock, mSendBuffer, len, 0);
    WBTRACE("Client socket send %s\n", mSendBuffer);
    if (len > 0) {
        mSendBuffer[0] = 0;
    }
    else if (len < 0) {
        WBTRACE("send fail!\n");
    }

    return len;
}

///////////////////////////////////////////////////////////

void SendSocketMessage(int instance, int event, const char *pData)
{   
    // Note: As the message sending buffer (mSendBuffer) is BUFFER_SIZE 
    // long, it may contains remaining message contents, so just fill 
    // in half of the BUFFER_SIZE message content (BUFFER_SIZE_HALF).
    char buf[BUFFER_SIZE];
    if (pData && strlen(pData) > 0) {
        if (strlen(pData) <= BUFFER_SIZE_HALF) {
            sprintf(buf, "%d,%d,%s%s", instance, event, pData, MSG_DELIMITER);
            
#ifdef WIN32
            EnterCriticalSection(&CriticalSection);
#else
            pthread_mutex_lock(&gServerMutex);
#endif

            gMessenger.Send(buf);

#ifdef WIN32
            LeaveCriticalSection(&CriticalSection);
#else
            pthread_mutex_unlock(&gServerMutex);
#endif
        } else {
            // in case pData is longer than BUFFER_SIZE_HALF, send it in 
            // multiple pieces.
            char pPartData[BUFFER_SIZE_HALF] = "\0";
            char* dataPtr = (char*)pData;

            // the head message piece.
            strncpy(pPartData, dataPtr, BUFFER_SIZE_HALF);
            // Note!!! this is important, to avoid additional, ending characters 
            // to be part of the message.
            pPartData[BUFFER_SIZE_HALF] = '\0';

            sprintf(buf, "%d,%d,%s%s", instance, event, pPartData, \
                MSG_DELIMITER_HEAD);

            dataPtr += BUFFER_SIZE_HALF;

#ifdef WIN32
            EnterCriticalSection(&CriticalSection);
#else
            pthread_mutex_lock(&gServerMutex);
#endif

            gMessenger.Send(buf);

#ifdef WIN32
            LeaveCriticalSection(&CriticalSection);
#else
            pthread_mutex_unlock(&gServerMutex);
#endif

            memset(buf, '\0', strlen(buf));
            memset(pPartData, '\0', strlen(pPartData));
            
            // multiple middle message pieces.
            while (strlen(dataPtr) > BUFFER_SIZE_HALF) {
                strncpy(pPartData, dataPtr, BUFFER_SIZE_HALF);
                pPartData[BUFFER_SIZE_HALF] = '\0';
                sprintf(buf, "%d,%d,%s%s", instance, event, pPartData, \
                    MSG_DELIMITER_MIDDLE);
                dataPtr += BUFFER_SIZE_HALF;

#ifdef WIN32
                EnterCriticalSection(&CriticalSection);
#else
                pthread_mutex_lock(&gServerMutex);
#endif

                int i = gMessenger.Send(buf);

#ifdef WIN32
                LeaveCriticalSection(&CriticalSection);
#else
                pthread_mutex_unlock(&gServerMutex);
#endif

                while (i == -1) {
                    // sleep in *millisecond*.
#ifdef WIN32
                    Sleep(SLEEP_INTERVAL_TIME);    
#else
                    usleep(SLEEP_INTERVAL_TIME);
#endif

#ifdef WIN32
                    EnterCriticalSection(&CriticalSection);
#else
                    pthread_mutex_lock(&gServerMutex);
#endif

                    i = gMessenger.Send(buf);

#ifdef WIN32
                    LeaveCriticalSection(&CriticalSection);
#else
                    pthread_mutex_unlock(&gServerMutex);
#endif
                }                

                memset(buf, '\0', strlen(buf));
                memset(pPartData, '\0', strlen(pPartData));
            }

            // the end message piece.
            strcpy(pPartData, dataPtr);
            pPartData[strlen(pPartData)] = '\0';
            sprintf(buf, "%d,%d,%s%s", instance, event, pPartData, \
                MSG_DELIMITER_END);

#ifdef WIN32
            EnterCriticalSection(&CriticalSection);
#else        
            pthread_mutex_lock(&gServerMutex);
#endif

            int i = gMessenger.Send(buf);

#ifdef WIN32
            LeaveCriticalSection(&CriticalSection);
#else
            pthread_mutex_unlock(&gServerMutex);
#endif
            while (i == -1) {
#ifdef WIN32
                Sleep(SLEEP_INTERVAL_TIME);    
#else
                usleep(SLEEP_INTERVAL_TIME);
#endif

#ifdef WIN32
                EnterCriticalSection(&CriticalSection);
#else
                pthread_mutex_lock(&gServerMutex);
#endif

                i = gMessenger.Send(buf);

#ifdef WIN32
                LeaveCriticalSection(&CriticalSection);
#else
                pthread_mutex_unlock(&gServerMutex);
#endif
            }
        }
    } else {
        sprintf(buf, "%d,%d%s", instance, event, MSG_DELIMITER);

#ifdef WIN32
        EnterCriticalSection(&CriticalSection);
#else
        pthread_mutex_lock(&gServerMutex);
#endif

        gMessenger.Send(buf);

#ifdef WIN32
        LeaveCriticalSection(&CriticalSection);
#else
        pthread_mutex_unlock(&gServerMutex);
#endif
    }
}

void AddTrigger(int instance, int msg, int *trigger)
{
#ifdef WIN32
    EnterCriticalSection(&CriticalSection);
#else
    pthread_mutex_lock(&gServerMutex);
#endif

    gMessenger.AddTrigger(instance, msg, trigger);

#ifdef WIN32
    LeaveCriticalSection(&CriticalSection);
#else
    pthread_mutex_unlock(&gServerMutex);
#endif
}

// this is a socket server listening thread function.
#ifdef _WIN32_IEEMBED
DWORD WINAPI PortListening(void *pParam)
#else
void PortListening(void *pParam)
#endif
{
    int ret = 0;

    gMessenger.SetHandler((MsgHandler)pParam);
    while (ret >= 0) {
#ifdef WIN32
        Sleep(SLEEP_INTERVAL_TIME);    
#else
        usleep(SLEEP_INTERVAL_TIME);
#endif

#ifdef WIN32
        EnterCriticalSection(&CriticalSection);
#else
        pthread_mutex_lock(&gServerMutex);
#endif

        ret = gMessenger.Listen();

#ifdef WIN32
        LeaveCriticalSection(&CriticalSection);
#else
        pthread_mutex_unlock(&gServerMutex);
#endif
    }

    WBTRACE("Quit listening thread. Quit app.\n");

    char buf[BUFFER_SIZE];
    sprintf(buf, "-1,%d%s", JEVENT_SHUTDOWN, MSG_DELIMITER);
    ((MsgHandler)pParam)(buf);

#ifdef _WIN32_IEEMBED
    return 0;
#endif
}