emaillistenerdestination.cpp

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

    fromStr.append(System::getEffectiveUserName());
    fromStr.append("@");
    fromStr.append(System::getFullyQualifiedHostName());

    // Write the fromStr to file
    _writeStrToFile(fromStr, filePtr);

    // Write the mailSubject string to file
    String mailSubjectStr = String::EMPTY;
    mailSubjectStr.append("Subject: ");
    mailSubjectStr.append(mailSubject);
    _writeStrToFile(mailSubjectStr, filePtr);
#endif

    PEG_METHOD_EXIT();
}

String EmailListenerDestination::_buildMailAddrStr(
    const Array<String>& mailAddr)
{
    PEG_METHOD_ENTER(TRC_IND_HANDLER,
        "EmailListenerDestination::_buildMailAddrStr");

    String mailAddrStr = String::EMPTY;
    Uint32 mailAddrSize = mailAddr.size();

    for (Uint32 i = 0; i < mailAddrSize; i++)
    {
#if defined(PEGASUS_OS_VMS)

        CString mailAddrVms = mailAddr[i].getCString();
        //
        // Add destination to message
        //
        address_itmlst[0].buffer_length = strlen(mailAddrVms);
        address_itmlst[0].buffer_address = (long &)mailAddrVms;

        status = mail$send_add_address(
            &send_context,
            address_itmlst,
            &nulllist);
        if (status != SS$_NORMAL)
        {
            PEG_TRACE_STRING(TRC_IND_HANDLER, Tracer::LEVEL4,
                "Routine mail$send_add_address failed.");
            PEG_METHOD_EXIT();

            throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(
                "Handler.EmailListenerDestination.EmailListenerDestination."
                    "ROUTINE_MAIL_SEND_ADD_ADDRESS_FAILED.PEGASUS_OS_VMS",
                "Routine mail$send_add_address failed."));
        }
        mailAddrStr = "VMS";
#else
        mailAddrStr.append(mailAddr[i]);

        if (i < (mailAddrSize - 1))
        {
            mailAddrStr.append(",");
        }
#endif
    }

    PEG_METHOD_EXIT();
    return  mailAddrStr;
}

#ifdef PEGASUS_OS_VMS
String EmailListenerDestination::_buildMailAddrCcStr(
    const Array<String>& mailAddr)
{
    PEG_METHOD_ENTER(TRC_IND_HANDLER,
        "EmailListenerDestination::_buildMailAddrCcStr");

    String mailAddrStr = String::EMPTY;
    Uint32 mailAddrSize = mailAddr.size();

    for (Uint32 i = 0; i < mailAddrSize; i++)
    {
        CString mailAddrCcVms = mailAddr[i].getCString();
        //
        // Add cc destination to message
        //
        address_cc_itmlst[0].buffer_length = strlen(mailAddrCcVms);
        address_cc_itmlst[0].buffer_address = (long &)mailAddrCcVms;

        status = mail$send_add_address(
            &send_context,
            address_cc_itmlst,
            &nulllist);
        if (status != SS$_NORMAL)
        {
            PEG_TRACE_STRING(TRC_IND_HANDLER, Tracer::LEVEL4,
                "Routine mail$send_add_address failed (cc).");
            PEG_METHOD_EXIT();

            throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(
                "Handler.EmailListenerDestination.EmailListenerDestination."
                    "ROUTINE_MAIL_SEND_ADD_ADDRESS_FAILED_CC.PEGASUS_OS_VMS",
                "Routine mail$send_add_address failed (cc)."));
        }
    }

    PEG_METHOD_EXIT();
    return mailAddrStr;
}

#endif

void EmailListenerDestination::_writeStrToFile(
    const String& mailHdrStr,
    FILE* filePtr)
{
    PEG_METHOD_ENTER(TRC_IND_HANDLER,
        "EmailListenerDestination::_writeStrToFile");

    String exceptionStr;

    if (fprintf(filePtr, "%s\n", (const char *) mailHdrStr.getCString()) < 0)
    {
        Tracer::trace(TRC_IND_HANDLER, Tracer::LEVEL4,
            "Failed to write the %s to the file: %s.",
            (const char *) mailHdrStr.getCString(),
            strerror(errno));

        MessageLoaderParms parms(
            "Handler.EmailListenerDestination.EmailListenerDestination."
                "_MSG_WRITE_TO_THE_FILE_FAILED",
            "Failed to write the $0 to the file: $1.",
            mailHdrStr,
            strerror(errno));

        exceptionStr.append(MessageLoader::getMessage(parms));

        PEG_METHOD_EXIT();

        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exceptionStr);
    }

    PEG_METHOD_EXIT();
}

void EmailListenerDestination::_sendMsg(
    char* mailFile)
{
    PEG_METHOD_ENTER(TRC_IND_HANDLER, "EmailListenerDestination::_sendMsg");

    String exceptionStr;
    char sendmailCmd[MAX_SENDMAIL_CMD_LEN];
    FILE* sendmailPtr;
    struct stat statBuf;

    // Checks the existence of the temp mail file
    if (!System::exists(mailFile))
    {
        Tracer::trace(TRC_IND_HANDLER, Tracer::LEVEL4,
            "File %s does not exist: %s.",
            mailFile,
            strerror(errno));

        MessageLoaderParms parms(
            "Handler.EmailListenerDestination.EmailListenerDestination."
                "_MSG_FILE_DOES_NOT_EXIST",
            "File $0 does not exist: $1.",
            mailFile,
            strerror(errno));

        exceptionStr.append(MessageLoader::getMessage(parms));

        PEG_METHOD_EXIT();

        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exceptionStr);
    }

    // Checks the length of the file since a zero length file causes
    // problems for sendmail()
    if (stat(mailFile, &statBuf) != 0)
    {
        Tracer::trace(TRC_IND_HANDLER, Tracer::LEVEL4,
            "Can not get file %s status: %s.",
            mailFile,
            strerror(errno));

        MessageLoaderParms parms(
            "Handler.EmailListenerDestination.EmailListenerDestination."
                "_MSG_CAN_NOT_GET_FILE_STATUS",
            "Can not get file $0 status: $1.",
            mailFile,
            strerror(errno));

        exceptionStr.append(MessageLoader::getMessage(parms));

        PEG_METHOD_EXIT();

        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exceptionStr);
    }

    if (statBuf.st_size == 0)
    {
        Tracer::trace(TRC_IND_HANDLER, Tracer::LEVEL4,
            "File %s does not contain any data.",
            mailFile);

        MessageLoaderParms parms(
            "Handler.EmailListenerDestination.EmailListenerDestination."
                "_MSG_FILE_DOES_NOT_CONTAIN_DATA",
            "File $0 does not contain any data.",
            mailFile);

        exceptionStr.append(MessageLoader::getMessage(parms));

        PEG_METHOD_EXIT();

        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exceptionStr);
    }

#ifdef PEGASUS_OS_VMS
    //
    // Send the mail message
    //
    status = mail$send_message(&send_context, nulllist, nulllist);
    if (status != SS$_NORMAL)
    {
        PEG_TRACE_STRING(TRC_IND_HANDLER, Tracer::LEVEL4,
            "Routine mail$send_message failed.");
        PEG_METHOD_EXIT();

        throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(
            "Handler.EmailListenerDestination.EmailListenerDestination."
                "ROUTINE_MAIL_SEND_MESSAGE_FAILED.PEGASUS_OS_VMS",
            "Routine mail$send_message failed."));
    }

    //
    // End mail send process
    //
    status = mail$send_end(&send_context, nulllist, nulllist);
    if (status != SS$_NORMAL)
    {
        PEG_TRACE_STRING(TRC_IND_HANDLER, Tracer::LEVEL4,
            "Routine mail$send_end failed.");
        PEG_METHOD_EXIT();

        throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(
            "Handler.EmailListenerDestination.EmailListenerDestination."
                "ROUTINE_MAIL_SEND_END_FAILED.PEGASUS_OS_VMS",
            "Routine mail$send_end failed."));
    }

#else
    sprintf(sendmailCmd, "%s %s %s", SENDMAIL_CMD, SENDMAIL_CMD_OPTS, mailFile);

    // Open the pipe to send the message
    if ((sendmailPtr = popen(sendmailCmd, "r")) == NULL)
    {
        Tracer::trace(TRC_IND_HANDLER, Tracer::LEVEL4,
            "popen of sendmail failed.");

        MessageLoaderParms parms(
            "Handler.EmailListenerDestination.EmailListenerDestination."
                "_MSG_POPEN_OF_SENDMAIL_FAILED",
            "popen of sendmail failed.");

        exceptionStr.append(MessageLoader::getMessage(parms));

        PEG_METHOD_EXIT();

        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exceptionStr);
    }

    // Close the pipe
    Sint32 retCode = pclose(sendmailPtr);
    if (retCode < 0)
    {
        Tracer::trace(TRC_IND_HANDLER, Tracer::LEVEL4,
            "No associated stream with this popen command.");

        MessageLoaderParms parms(
            "Handler.EmailListenerDestination.EmailListenerDestination."
                "_MSG_NO_ASSOCIATED_STREAM",
            "No associated stream with this popen command.");

        exceptionStr.append(MessageLoader::getMessage(parms));

        PEG_METHOD_EXIT();

        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exceptionStr);
    }
    else if (retCode == SH_EXECUTE_FAILED)
    {
        Tracer::trace(TRC_IND_HANDLER, Tracer::LEVEL4,
            "/usr/bin/sh could not be executed.");

        MessageLoaderParms parms(
            "Handler.EmailListenerDestination.EmailListenerDestination."
                "_MSG_SHELL_CAN_NOT_BE_EXECUTED",
            "/usr/bin/sh could not be executed.");

        exceptionStr.append(MessageLoader::getMessage(parms));

        PEG_METHOD_EXIT();

        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exceptionStr);
    }
#endif

    PEG_METHOD_EXIT();
}

void EmailListenerDestination::_openFile(
    FILE** filePtr,
    char* mailFile)
{
    PEG_METHOD_ENTER(TRC_IND_HANDLER,
        "EmailListenerDestination::_openFile");

    String exceptionStr;

    *filePtr = fopen(tmpnam(mailFile), "w");
#ifdef PEGASUS_OS_VMS
    strcpy(mailFileVms, mailFile);
#endif
    if (*filePtr == NULL)
    {
        Tracer::trace(TRC_IND_HANDLER, Tracer::LEVEL4,
            "fopen of %s failed: %s.", mailFile,
            strerror(errno));

        MessageLoaderParms parms(
            "Handler.EmailListenerDestination.EmailListenerDestination."
                "_MSG_FAILED_TO_OPEN_THE_FILE",
            "fopen of $0 failed: $1.",
            mailFile,
            strerror(errno));

        exceptionStr.append(MessageLoader::getMessage(parms));

        PEG_METHOD_EXIT();

        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exceptionStr);
    }

    PEG_METHOD_EXIT();
}

PEGASUS_NAMESPACE_END

PEGASUS_USING_PEGASUS;

// This is the entry point into this dynamic module.

extern "C" PEGASUS_EXPORT CIMHandler* PegasusCreateHandler(
    const String& handlerName)
{
    if (handlerName == "EmailListenerDestination")
    {
        return new EmailListenerDestination;
    }

    return 0;
}