mnotify.c

彩信MMS的全部代码

    case MMS_SIG_MSR_IMMEDIATE_RETRIEVAL_FINISHED:
        immediateRetrievalFinished( (MmsSigMsrReceiveParam *)sig->p_param);
        fsm.state = MSR_IDLE;
        break;
    case MMS_SIG_MSR_REMOVE_DELAYED_NOTIFICATION:
        msrNotifyRemoveId( NOTIF_DELAYED, sig->u_param1);
        break;
    case MMS_SIG_MSR_CHECK_IMMEDIATE_RETRIEVALS:
        
		MMS_LOG_I(("MSR Notify FSM, Received MMS_SIG_MSR_CHECK_IMMEDIATE_RETRIEVALS\n"));
        immediateRetrievalCheck();
        break;
    case MMS_SIG_MSR_SEND_NOTIFY_RESP:
        sendNotifyRespInd( FALSE, sig->p_param, MMS_STATUS_REJECTED, 
            (MmsClassIdentifier)sig->u_param2, (MmsVersion)sig->u_param1);
        M_FREE(sig->p_param);
        break;
    case MMS_SIG_COMMON_TIMER_EXPIRED :
        MMS_LOG_I(("Notify: TIMER_EXPIRED. Time to check if they're less busy\n"));
        immediateRetrievalCheck();
        break;
	default :
		 MMS_LOG_I(("%s(%d): Received unsupported sig %d\n",
             __FILE__, __LINE__, sig->type));
		break;
	} 

    mSignalDelete(sig);
} 





void msrNotifyTerminate(MmsShutdown condition)
{
    M_TIMER_RESET(M_FSM_MSR_NOTIFY);

    if (condition == MMS_SHUTDOWN_NORMAL)
    {
        notifTableSaveAll();
    }
    else
    {
        MMS_LOG_I(("%s(%d): Abnormal shutdown."
            " Save notification table without using cache.\n",
            __FILE__, __LINE__));

        notifTableSaveAllNoCache();
    } 

    notifTableFreeMemory();
    mSignalDeregister(M_FSM_MSR_NOTIFY);
    MMS_LOG_I(("MMS FSM MSR NOTIFY: MSR_notifyTerminate\n"));
} 











static CMN_BOOL notifFileRead(UINT32 fileId, MmsTimeSec *time, 
    CMN_BOOL *isSmsBearer, UINT32 *len, unsigned char **pdu)
{
    int ret;
    INT32 expected; 
    INT32 actually; 
    
    *isSmsBearer = FALSE;
    *len = 0;
    *pdu = NULL;

    ret = FILEa_open( MMS_FILE_CATEGORY_IMMEDIATE, fileId, FILE_OPTION_READ);
    if (ret != 0)
    {
        MMS_LOG_I(("%s(%d): Couldn't open file %lu\n", __FILE__, __LINE__, fileId));
        return FALSE;
    } 

    
    expected = 0;
    actually = 0;
    actually += FILEa_read( MMS_FILE_CATEGORY_IMMEDIATE, fileId, 
        time, actually, sizeof(MmsTimeSec));
    actually += FILEa_read( MMS_FILE_CATEGORY_IMMEDIATE, fileId, 
        isSmsBearer, actually, sizeof(CMN_BOOL));
    actually += FILEa_read( MMS_FILE_CATEGORY_IMMEDIATE, fileId, 
        len, actually, sizeof(UINT32));

    if (*len > MMS_MAX_NOTIFICATION_SIZE)
    {
        MMS_LOG_I(("%s(%d): Notification size %lu exceeds configured max %d\n", 
            __FILE__, __LINE__, *len, MMS_MAX_NOTIFICATION_SIZE));
        FILEa_close( MMS_FILE_CATEGORY_IMMEDIATE, fileId);
        return FALSE;
    } 

    *pdu = M_ALLOC(*len);
    actually += FILEa_read( MMS_FILE_CATEGORY_IMMEDIATE, fileId, 
        *pdu, actually, (INT32)*len);
    expected = (INT32)(sizeof(MmsTimeSec) + sizeof(CMN_BOOL) + sizeof(UINT32) + *len);

    FILEa_close( MMS_FILE_CATEGORY_IMMEDIATE, fileId);

    if (actually != expected)
    {
        MMS_LOG_I(("%s(%d): Failed to read notification\n", __FILE__, __LINE__));

        FILEa_delete( MMS_FILE_CATEGORY_IMMEDIATE, fileId);
        M_FREE(*pdu);
    } 

    return actually == expected;
} 










static UINT32 notifFileWrite(MmsTimeSec time, CMN_BOOL isSmsBearer, 
    unsigned char *pdu, UINT32 len)
{
    UINT32 fileId;
    INT32 actually; 
    INT32 expected; 
    
    if (FILEa_create( MMS_FILE_CATEGORY_IMMEDIATE, NULL, &fileId) == -1)
    {
        MMS_LOG_I(("%s(%d): Failed to create file for "
            "immediate retrieval notification\n", __FILE__, __LINE__));

        MMSa_error( MMS_RESULT_INSUFFICIENT_PERSISTENT_STORAGE);
        return 0;
    } 

    
    actually = 0;
    expected = (INT32)(sizeof(time) + sizeof(isSmsBearer) + sizeof(len) + len);
    actually += FILEa_write(MMS_FILE_CATEGORY_IMMEDIATE, fileId, 
        &time, actually, sizeof(time));
    actually += FILEa_write(MMS_FILE_CATEGORY_IMMEDIATE, fileId, 
        &isSmsBearer, actually, sizeof(isSmsBearer));
    actually += FILEa_write(MMS_FILE_CATEGORY_IMMEDIATE, fileId, 
        &len, actually, sizeof(len));
    actually += FILEa_write(MMS_FILE_CATEGORY_IMMEDIATE, fileId, 
        pdu, actually, (INT32)len);

    FILEa_close( MMS_FILE_CATEGORY_IMMEDIATE, fileId);

    if (actually != expected)
    {
        MMS_LOG_I(("%s(%d): Failed to store notification\n", __FILE__, __LINE__));

        FILEa_delete( MMS_FILE_CATEGORY_IMMEDIATE, fileId);
        MMSa_error( MMS_RESULT_INSUFFICIENT_PERSISTENT_STORAGE);
        fileId = 0;
    } 

    return fileId;
} 





static void notifInit(void)
{
    int     nrOfFiles = 0;
    UINT32  *allFileIds = NULL;

    
    nrOfFiles = FILEa_getFileIds( MMS_FILE_CATEGORY_IMMEDIATE, NULL, 0);
    if (nrOfFiles <= 0)
    {
        return;
    } 

    allFileIds = M_ALLOC((UINT32)nrOfFiles * sizeof(UINT32)); 
    if (allFileIds == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));
        MMSa_error(MMS_RESULT_RESTART_NEEDED);
        return;
    } 

    memset( allFileIds, 0, (UINT32)nrOfFiles * sizeof(UINT32)); 
    if (FILEa_getFileIds( MMS_FILE_CATEGORY_IMMEDIATE, allFileIds, nrOfFiles) <= 0)    
    {
        MMS_LOG_I(("%s(%d): FILEa_getFileIds returned error\n", 
            __FILE__, __LINE__));
    } 

    


    while ( --nrOfFiles >= 0)
    {
        FILEa_close( MMS_FILE_CATEGORY_IMMEDIATE, allFileIds[nrOfFiles]);
    } 

    M_FREE( allFileIds);
} 








static CMN_BOOL notifIsEqual( const char *uri, const MmsNotification *notif)
{
    return uri != NULL && notif != NULL && notif->contentLocation != NULL &&
        cmnStrcmpNc( uri, notif->contentLocation) == 0;
} 






void msrNotifyRemoveId(MmsMsrNotifStorageType type, UINT32 id)
{
    int i;
    FmResult fmResult;

    if (id == NOTIF_TABLE_FILE_ID)
    {
        MMS_LOG_I(("%s(%d): Trying to remove file %d\n", 
            __FILE__, __LINE__, NOTIF_TABLE_FILE_ID));
        return;
    } 

    
    for ( i = 0; i < fsm.notifTable.count; ++i)
    {   
        if (id == fsm.notifTable.notif[i].fileId && 
            type == fsm.notifTable.notif[i].type)
        {
            notifTableRemove(i);
            break;
        } 
    } 

    
    if (type == NOTIF_IMMEDIATE)
    {
        FILEa_delete( MMS_FILE_CATEGORY_IMMEDIATE, id);
    }
    else if (type == NOTIF_DELAYED)
    {
        fmResult = fldrmgrDeleteMsg( CMN_CLIENT_MMS, id, TRUE);
        if (checkFolderError(fmResult) != MMS_RESULT_OK)
        {   
            MMS_LOG_I(("MMS INFO: Notification was already removed? (%d) file %lu\n", 
                fmResult, id));
        }  
    } 
} 











static UINT32 notifTableDecodeData( const char *buf, UINT32 len)
{
    UINT32 fileId;          
    MmsMsrNotifStorageType type;  
    UINT32 decodedBytes = 0;
    UINT32 pos = 0;
    unsigned long strLen;

    while (decodedBytes < len && 
        fsm.notifTable.count < MMS_MAX_DUPLICATE_NOTIFICATION_CHECK)
    {
        if (pos + sizeof(fileId) >= len)
        {   
            break;
        } 
        memcpy( &fileId, buf+pos, sizeof(fileId));
        pos += sizeof(fileId);

        if (pos + sizeof(type) >= len)
        {   
            break;
        } 
        memcpy( &type, buf+pos, sizeof(type));
        pos += sizeof(type);

        strLen = cmnStrnlen( buf + pos, len - pos);
        if (strLen > 0 && buf[pos + strLen - 1] != EOS)
        {   

            break;
        } 

        
        fsm.notifTable.notif[ fsm.notifTable.count ].fileId = fileId;
        fsm.notifTable.notif[ fsm.notifTable.count ].type = type;
        fsm.notifTable.notif[ fsm.notifTable.count ].retries = 0;

        
        fsm.notifTable.notif[ fsm.notifTable.count ].uri = M_ALLOC(strlen(&buf[pos]) + 1);
        strcpy( fsm.notifTable.notif[fsm.notifTable.count].uri, &buf[pos]);
        ++fsm.notifTable.count;

        pos += strLen + 1;

        decodedBytes = pos;
    } 

    return decodedBytes;
} 








static MmsMsrNotifStorageType notifTableEntryExists(const MmsNotification *notif)
{
    int i;

    
    for ( i = 0; i < fsm.notifTable.count; ++i)
    {
        if (notifIsEqual( fsm.notifTable.notif[i].uri, notif))
        {
            return fsm.notifTable.notif[i].type;
        } 
    } 

    return NOTIF_UNSTORED;
} 





static void notifTableFreeMemory(void)
{
    int i;

    for (i = 0; i < fsm.notifTable.count; ++i)
    {
        M_FREE( fsm.notifTable.notif[i].uri);
    } 

    memset( &fsm.notifTable, 0, sizeof(MsrNotifTable));
    fsm.notifTable.count = 0;
} 








static void notifTableInsert( MmsMsrNotifStorageType type, UINT32 fileId, 
    const char *uri)
{
    if (uri == NULL || fileId == 0)
    {
        MMS_LOG_I(("%s(%d): Illegal data: %lu, %d, %s\n", __FILE__, __LINE__, 
            fileId, type, uri == NULL ? "NULL" : uri));
        return;
    } 

    
    if (fsm.notifTable.count > 0)
    {
        
        if (fsm.notifTable.count == MMS_MAX_DUPLICATE_NOTIFICATION_CHECK)
        {
            
            M_FREE( fsm.notifTable.notif[fsm.notifTable.count - 1].uri);
            memmove( &fsm.notifTable.notif[1], &fsm.notifTable.notif[0], 
                sizeof(fsm.notifTable.notif) - sizeof(MsrNotifTableData));
        }
        else
        {
            memmove( &fsm.notifTable.notif[1], &fsm.notifTable.notif[0], 
                (unsigned)fsm.notifTable.count * sizeof(MsrNotifTableData));
        } 
    } 

    
    fsm.notifTable.notif[0].fileId = fileId;
    fsm.notifTable.notif[0].type = type;
    fsm.notifTable.notif[0].retries = 0;

    
    fsm.notifTable.notif[0].uri = M_ALLOC( strlen(uri) + 1);
    strcpy( fsm.notifTable.notif[0].uri, uri);

    
    if (fsm.notifTable.count < MMS_MAX_DUPLICATE_NOTIFICATION_CHECK)
    {
        ++fsm.notifTable.count;
    } 

#if MMS_NOTIF_TABLE_SAVE_CREATE
    notifTableSaveAll();
#endif
} 





static void notifTableRead(void)
{
    char *buffer;       
    char *storePos;     
    UINT32 bufSize = MMS_MAX_CHUNK_SIZE;
    UINT32 bufFree = bufSize;    
    int ret;
    UINT32 decodedBytes;
    int fileSize;
    INT32 bytesRead = 0;
    INT32 readPos = 0;  

    fileSize = FILEa_getSize( MMS_FILE_CATEGORY_IMMEDIATE, NOTIF_TABLE_FILE_ID);
    if (fileSize <= -1)
    {
        MMS_LOG_I(("%s(%d): FILEa_getSize returned %d\n", 
            __FILE__, __LINE__, fileSize));
        return;
    }
    else if (fileSize == 0)
    {
        MMS_LOG_I(("notifTableRead: No stored immediate retrieval "
            "notifications found. All immediate retrievals are finished.\n"));
        return;
    } 

    ret = FILEa_open( MMS_FILE_CATEGORY_IMMEDIATE, NOTIF_TABLE_FILE_ID, 
        FILE_OPTION_READ);
    if (ret != 0)
    {
        MMS_LOG_I(("%s(%d): Couldn't open file %d\n", __FILE__, __LINE__,
            NOTIF_TABLE_FILE_ID));
        return;
    } 

    if ((UINT32)fileSize < MMS_MAX_CHUNK_SIZE)
    {   
        

        bufSize = (UINT32)fileSize;
    } 

    buffer = M_ALLOC(bufSize);
    if (buffer == NULL)
    {
        MMS_LOG_I(("%s(%d): Out of memory\n", __FILE__, __LINE__));