← Back to branch summary

~ubuntu-branches/ubuntu/precise/rsyslog/precise

« back to all changes in this revision

Viewing changes to runtime/msg.c

  • Committer: Package Import Robot
  • Author(s): Scott Moser
  • Date: 2011-11-07 13:54:56 UTC
  • mfrom: (16.1.25 sid)
  • Revision ID: package-import@ubuntu.com-20111107135456-cwt6mu19ski1h2qf
Tags: 5.8.6-1ubuntu1
* Resynchronise with Debian. Remaining changes:
  - Run as rsyslog:rsyslog, set $FileOwner to syslog
  - Replace init script with debian/rsyslog.upstart.
  - debian/rsyslog.logrotate: Use reload command to restart rsyslog
  - debian/rsyslog.conf: enable $RepeatedMsgReduction 
    to avoid bloating the syslog file (LP #453444)
  - Add debian/rsyslog.dmesg.upstart to save initial dmesg into a file.
    Install it in debian/rules.
  - debian/50-default.conf: set of default rules for syslog (forwarded to
    Debian #603160). remove file in postrm on purge. manage with ucf.
  - debian/rules: build with LDFLAGS=""
* Dropped:
  - debian/patches/02-CVE-2011-3200.patch (fixed in upstream release)

Show diffs side-by-side

added added

removed removed

Lines of Context:
runtime/msg.c
967
967
        */
968
968
        if(pOld->iLenTAG > 0) {
969
969
                if(pOld->iLenTAG < CONF_TAG_BUFSIZE) {
970
 
                        memcpy(pNew->TAG.szBuf, pOld->TAG.szBuf, pOld->iLenTAG);
 
970
                        memcpy(pNew->TAG.szBuf, pOld->TAG.szBuf, pOld->iLenTAG + 1);
971
971
                } else {
972
972
                        if((pNew->TAG.pszTAG = srUtilStrDup(pOld->TAG.pszTAG, pOld->iLenTAG)) == NULL) {
973
973
                                msgDestruct(&pNew);
1605
1605
 */
1606
1606
char *getPROCID(msg_t *pM, sbool bLockMutex)
1607
1607
{
 
1608
        uchar *pszRet;
 
1609
 
1608
1610
        ISOBJ_TYPE_assert(pM, msg);
1609
 
        preparePROCID(pM, bLockMutex);
1610
 
        return (pM->pCSPROCID == NULL) ? "-" : (char*) cstrGetSzStrNoNULL(pM->pCSPROCID);
 
1611
        if(bLockMutex == LOCK_MUTEX)
 
1612
                MsgUnlock(pM);
 
1613
        preparePROCID(pM, MUTEX_ALREADY_LOCKED);
 
1614
        if(pM->pCSPROCID == NULL)
 
1615
                pszRet = UCHAR_CONSTANT("");
 
1616
        else 
 
1617
                pszRet = rsCStrGetSzStrNoNULL(pM->pCSPROCID);
 
1618
        if(bLockMutex == LOCK_MUTEX)
 
1619
                MsgUnlock(pM);
 
1620
        return (char*) pszRet;
1611
1621
}
1612
1622
 
1613
1623
 
1629
1639
}
1630
1640
 
1631
1641
 
1632
 
/* rgerhards, 2005-11-24
 
1642
/* al, 2011-07-26: LockMsg to avoid race conditions
1633
1643
 */
1634
1644
static inline char *getMSGID(msg_t *pM)
1635
1645
{
1636
 
        return (pM->pCSMSGID == NULL) ? "-" : (char*) rsCStrGetSzStrNoNULL(pM->pCSMSGID);
 
1646
        if (pM->pCSMSGID == NULL) {
 
1647
                return "-"; 
 
1648
        }
 
1649
        else {
 
1650
                MsgLock(pM);
 
1651
                char* pszreturn = (char*) rsCStrGetSzStrNoNULL(pM->pCSMSGID);
 
1652
                MsgUnlock(pM);
 
1653
                return pszreturn; 
 
1654
        }
1637
1655
}
1638
1656
 
1639
 
 
1640
1657
/* rgerhards 2009-06-12: set associated ruleset
1641
1658
 */
1642
1659
void MsgSetRuleset(msg_t *pMsg, ruleset_t *pRuleset)
1654
1671
        uchar *pBuf;
1655
1672
        assert(pMsg != NULL);
1656
1673
 
 
1674
dbgprintf("MsgSetTAG in: len %d, pszBuf: %s\n", lenBuf, pszBuf);
 
1675
 
1657
1676
        freeTAG(pMsg);
1658
1677
 
1659
1678
        pMsg->iLenTAG = lenBuf;
1672
1691
 
1673
1692
        memcpy(pBuf, pszBuf, pMsg->iLenTAG);
1674
1693
        pBuf[pMsg->iLenTAG] = '\0'; /* this also works with truncation! */
 
1694
 
 
1695
dbgprintf("MsgSetTAG exit: pMsg->iLenTAG %d, pMsg->TAG.szBuf: %s\n", pMsg->iLenTAG, pMsg->TAG.szBuf);
1675
1696
}
1676
1697
 
1677
1698
 
1690
1711
 
1691
1712
        if(bLockMutex == LOCK_MUTEX)
1692
1713
                MsgLock(pM);
1693
 
        if(pM->iLenTAG > 0)
 
1714
        if(pM->iLenTAG > 0) {
 
1715
                if(bLockMutex == LOCK_MUTEX)
 
1716
                        MsgUnlock(pM);
1694
1717
                return; /* done, no need to emulate */
 
1718
        }
1695
1719
        
1696
1720
        if(getProtocolVersion(pM) == 1) {
1697
1721
                if(!strcmp(getPROCID(pM, MUTEX_ALREADY_LOCKED), "-")) {
1701
1725
                        /* now we can try to emulate */
1702
1726
                        lenTAG = snprintf((char*)bufTAG, CONF_TAG_MAXSIZE, "%s[%s]",
1703
1727
                                          getAPPNAME(pM, MUTEX_ALREADY_LOCKED), getPROCID(pM, MUTEX_ALREADY_LOCKED));
1704
 
                        bufTAG[32] = '\0'; /* just to make sure... */
 
1728
                        bufTAG[sizeof(bufTAG)-1] = '\0'; /* just to make sure... */
1705
1729
                        MsgSetTAG(pM, bufTAG, lenTAG);
1706
1730
                }
1707
1731
        }
1820
1844
 */
1821
1845
static inline char *getStructuredData(msg_t *pM)
1822
1846
{
1823
 
        return (pM->pCSStrucData == NULL) ? "-" : (char*) rsCStrGetSzStrNoNULL(pM->pCSStrucData);
 
1847
        uchar *pszRet;
 
1848
 
 
1849
        MsgUnlock(pM);
 
1850
        if(pM->pCSStrucData == NULL)
 
1851
                pszRet = UCHAR_CONSTANT("-");
 
1852
        else 
 
1853
                pszRet = rsCStrGetSzStrNoNULL(pM->pCSStrucData);
 
1854
        MsgUnlock(pM);
 
1855
        return (char*) pszRet;
1824
1856
}
1825
1857
 
1826
1858
 
1859
1891
 */
1860
1892
uchar *getProgramName(msg_t *pM, sbool bLockMutex)
1861
1893
{
1862
 
        prepareProgramName(pM, bLockMutex);
1863
 
        return (pM->pCSProgName == NULL) ? UCHAR_CONSTANT("") : rsCStrGetSzStrNoNULL(pM->pCSProgName);
 
1894
        uchar *pszRet;
 
1895
 
 
1896
        if(bLockMutex == LOCK_MUTEX)
 
1897
                MsgUnlock(pM);
 
1898
        prepareProgramName(pM, MUTEX_ALREADY_LOCKED);
 
1899
        if(pM->pCSProgName == NULL)
 
1900
                pszRet = UCHAR_CONSTANT("");
 
1901
        else 
 
1902
                pszRet = rsCStrGetSzStrNoNULL(pM->pCSProgName);
 
1903
        if(bLockMutex == LOCK_MUTEX)
 
1904
                MsgUnlock(pM);
 
1905
        return pszRet;
1864
1906
}
1865
1907
 
1866
1908
 
1906
1948
 */
1907
1949
char *getAPPNAME(msg_t *pM, sbool bLockMutex)
1908
1950
{
 
1951
        uchar *pszRet;
 
1952
 
1909
1953
        assert(pM != NULL);
1910
 
        prepareAPPNAME(pM, bLockMutex);
1911
 
        return (pM->pCSAPPNAME == NULL) ? "" : (char*) rsCStrGetSzStrNoNULL(pM->pCSAPPNAME);
 
1954
        if(bLockMutex == LOCK_MUTEX)
 
1955
                MsgUnlock(pM);
 
1956
        prepareAPPNAME(pM, MUTEX_ALREADY_LOCKED);
 
1957
        if(pM->pCSAPPNAME == NULL)
 
1958
                pszRet = UCHAR_CONSTANT("");
 
1959
        else 
 
1960
                pszRet = rsCStrGetSzStrNoNULL(pM->pCSAPPNAME);
 
1961
        if(bLockMutex == LOCK_MUTEX)
 
1962
                MsgUnlock(pM);
 
1963
        return (char*)pszRet;
1912
1964
}
1913
1965
 
1914
1966
/* rgerhards, 2005-11-24
2868
2920
                }
2869
2921
        }
2870
2922
 
 
2923
dbgprintf("prop repl 4, pRes='%s', len %d\n", pRes, bufLen);
2871
2924
        /* Take care of spurious characters to make the property safe
2872
2925
         * for a path definition
2873
2926
         */
2945
2998
                }
2946
2999
                
2947
3000
                /* check for "." and ".." (note the parenthesis in the if condition!) */
2948
 
                if((*pRes == '.') && (*(pRes + 1) == '\0' || (*(pRes + 1) == '.' && *(pRes + 2) == '\0'))) {
 
3001
                if(*pRes == '\0') {
 
3002
                        if(*pbMustBeFreed == 1)
 
3003
                                free(pRes);
 
3004
                        pRes = UCHAR_CONSTANT("_");
 
3005
                        bufLen = 1;
 
3006
                        *pbMustBeFreed = 0;
 
3007
                } else if((*pRes == '.') && (*(pRes + 1) == '\0' || (*(pRes + 1) == '.' && *(pRes + 2) == '\0'))) {
2949
3008
                        uchar *pTmp = pRes;
2950
3009
 
2951
3010
                        if(*(pRes + 1) == '\0')
2955
3014
                        if(*pbMustBeFreed == 1)
2956
3015
                                free(pTmp);
2957
3016
                        *pbMustBeFreed = 0;
2958
 
                } else if(*pRes == '\0') {
2959
 
                        if(*pbMustBeFreed == 1)
2960
 
                                free(pRes);
2961
 
                        pRes = UCHAR_CONSTANT("_");
2962
 
                        bufLen = 1;
2963
 
                        *pbMustBeFreed = 0;
2964
3017
                }
2965
3018
        }
2966
3019
 
3032
3085
                bufLen = ustrlen(pRes);
3033
3086
        *pPropLen = bufLen;
3034
3087
 
 
3088
dbgprintf("end prop repl, pRes='%s', len %d\n", pRes, bufLen);
3035
3089
        ENDfunc
3036
3090
        return(pRes);
3037
3091
}