Changeset 481 for trunk/src


Ignore:
Timestamp:
Jul 18, 2015, 5:06:52 PM (9 years ago)
Author:
katerina
Message:

Enhancements and fixes for tickets #374, #375, #376, #377, #378, and #379.

Location:
trunk/src
Files:
9 added
7 deleted
62 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/cutest_sh_tiger0.c

    r444 r481  
    2828  if (skey != NULL)
    2929    {
    30       skey->mlock_failed = SL_FALSE;
     30      skey->mlock_failed = S_FALSE;
    3131      skey->rngI         = BAD;
    3232      /* properly initialized later

  • trunk/src/cutest_sh_unix.c

    r474 r481  
    1414  int j, i;
    1515  int sum;
     16#ifndef USE_SYSTEM_MALLOC
    1617  int i_malloc =  malloc_count;
     18#endif
    1719
    1820  char * buf;
    … …  
    3537  CuAssertStrEquals(tc, "testing realloctesting realloc", buf);
    3638
     39#ifndef USE_SYSTEM_MALLOC
    3740  i_malloc = malloc_count;
     41#endif
    3842
    3943  for (j = 0; j < 64; ++j)
    … …  
    6064  CuAssertStrEquals(tc, "testing realloctesting realloc", buf);
    6165
     66#ifndef USE_SYSTEM_MALLOC
    6267  i_malloc = malloc_count;
     68#endif
    6369
    6470  for (j = 0; j < 64; ++j)
    … …  
    97103    }
    98104
     105#ifndef USE_SYSTEM_MALLOC
    99106  i_malloc =  malloc_count;
     107#endif
    100108
    101109  for (j = 0; j < nalloc; ++j)
    … …  
    122130  for (j = 0; j < 32; ++j)
    123131    {
     132#ifndef USE_SYSTEM_MALLOC
    124133      i_malloc =  malloc_count;
     134#endif
    125135      buf = malloc((j+1) * 1024 * 1024);
    126136      CuAssertPtrNotNull(tc, buf);

  • trunk/src/cutest_sh_utils.c

    r444 r481  
    531531}
    532532
    533 

  • trunk/src/cutest_zAVLTree.c

    r452 r481  
    2121static zAVLKey ztest_intkey(void const *item)
    2222{
    23   return (&((struct ztest *)item)->iname);
     23  return (&((const struct ztest *)item)->iname);
    2424}
    2525

  • trunk/src/dnmalloc.c

    r383 r481  
    220220#ifdef linux
    221221#define HAVE_MREMAP 1
    222 #define _GNU_SOURCE
     222#define _GNU_SOURCE 1
    223223#else
    224224#define HAVE_MREMAP 0
    … …  
    310310  char * i3 = "): ";
    311311  char * i5 = "\n";
    312   int   res = 0;
    313 
    314   iov[0].iov_base = i1;               iov[0].iov_len = strlen(i1);
    315   iov[1].iov_base = (char*) file;     iov[1].iov_len = strlen(file);
    316   iov[2].iov_base = i3;               iov[2].iov_len = strlen(i3);
    317   iov[3].iov_base = (char*) error;    iov[3].iov_len = strlen(error);
    318   iov[4].iov_base = i5;               iov[4].iov_len = strlen(i5);
     312  int    res = 0;
     313  char   ifile[128];
     314  char   ierr[128];
     315
     316  strncpy(ifile, file, sizeof(ifile)); ifile[sizeof(ifile)-1] = '\0';
     317  strncpy(ierr, error, sizeof(ierr));  ierr[sizeof(ierr)-1]   = '\0';
     318
     319  iov[0].iov_base = i1;     iov[0].iov_len = strlen(i1);
     320  iov[1].iov_base = ifile;  iov[1].iov_len = strlen(ifile);
     321  iov[2].iov_base = i3;     iov[2].iov_len = strlen(i3);
     322  iov[3].iov_base = ierr;   iov[3].iov_len = strlen(ierr);
     323  iov[4].iov_base = i5;     iov[4].iov_len = strlen(i5);
    319324  do {
    320325    res = writev(STDERR_FILENO, iov, 5);
    … …  
    343348
    344349static assert_handler_tp *assert_handler = NULL;
     350#ifndef NDEBUG
    345351#define NDEBUG
     352#endif
    346353#define assert(x) ((void)0)
    347354
    … …  
    37643771    } /* not extended previous region */
    37653772   
    3766     /* Update statistics */ /* FIXME check this */
     3773    /* Update statistics */
    37673774    sum = av->sbrked_mem;
    37683775    if (sum > (CHUNK_SIZE_T)(av->max_sbrked_mem))

  • trunk/src/rijndael-alg-fst.c

    r440 r481  
     1/*      $NetBSD: rijndael-alg-fst.c,v 1.7 2005/12/11 12:20:52 christos Exp $    */
     2/*      $KAME: rijndael-alg-fst.c,v 1.10 2003/07/15 10:47:16 itojun Exp $       */
     3/**
     4 * rijndael-alg-fst.c
     5 *
     6 * @version 3.0 (December 2000)
     7 *
     8 * Optimised ANSI C code for the Rijndael cipher (now AES)
     9 *
     10 * @author Vincent Rijmen <vincent.rijmen@esat.kuleuven.ac.be>
     11 * @author Antoon Bosselaers <antoon.bosselaers@esat.kuleuven.ac.be>
     12 * @author Paulo Barreto <paulo.barreto@terra.com.br>
     13 *
     14 * This code is hereby placed in the public domain.
     15 *
     16 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ''AS IS'' AND ANY EXPRESS
     17 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE
     20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
     23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
     25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
     26 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27 */
     28
     29#include "config_xor.h"
     30
     31#include <sys/types.h>
     32#include <string.h>
     33
     34#ifdef SH_ENCRYPT
     35
     36typedef unsigned char u8;
     37#if defined(HAVE_INT_32)
     38typedef unsigned int u32;
     39#elif defined(HAVE_LONG_32)
     40typedef unsigned long u32;
     41#elif defined(HAVE_SHORT_32)
     42typedef unsigned short u32;
     43#else
     44#error "No 32 bit integer type found"
     45#endif
     46
     47#include "rijndael-alg-fst.h"
     48
     49#define FULL_UNROLL 1
    150/*
    2  * rijndael-alg-fst.c   v2.3   April '2000
     51Te0[x] = S [x].[02, 01, 01, 03];
     52Te1[x] = S [x].[03, 02, 01, 01];
     53Te2[x] = S [x].[01, 03, 02, 01];
     54Te3[x] = S [x].[01, 01, 03, 02];
     55Te4[x] = S [x].[01, 01, 01, 01];
     56
     57Td0[x] = Si[x].[0e, 09, 0d, 0b];
     58Td1[x] = Si[x].[0b, 0e, 09, 0d];
     59Td2[x] = Si[x].[0d, 0b, 0e, 09];
     60Td3[x] = Si[x].[09, 0d, 0b, 0e];
     61Td4[x] = Si[x].[01, 01, 01, 01];
     62*/
     63
     64static const u32 Te0[256] = {
     65    0xc66363a5U, 0xf87c7c84U, 0xee777799U, 0xf67b7b8dU,
     66    0xfff2f20dU, 0xd66b6bbdU, 0xde6f6fb1U, 0x91c5c554U,
     67    0x60303050U, 0x02010103U, 0xce6767a9U, 0x562b2b7dU,
     68    0xe7fefe19U, 0xb5d7d762U, 0x4dababe6U, 0xec76769aU,
     69    0x8fcaca45U, 0x1f82829dU, 0x89c9c940U, 0xfa7d7d87U,
     70    0xeffafa15U, 0xb25959ebU, 0x8e4747c9U, 0xfbf0f00bU,
     71    0x41adadecU, 0xb3d4d467U, 0x5fa2a2fdU, 0x45afafeaU,
     72    0x239c9cbfU, 0x53a4a4f7U, 0xe4727296U, 0x9bc0c05bU,
     73    0x75b7b7c2U, 0xe1fdfd1cU, 0x3d9393aeU, 0x4c26266aU,
     74    0x6c36365aU, 0x7e3f3f41U, 0xf5f7f702U, 0x83cccc4fU,
     75    0x6834345cU, 0x51a5a5f4U, 0xd1e5e534U, 0xf9f1f108U,
     76    0xe2717193U, 0xabd8d873U, 0x62313153U, 0x2a15153fU,
     77    0x0804040cU, 0x95c7c752U, 0x46232365U, 0x9dc3c35eU,
     78    0x30181828U, 0x379696a1U, 0x0a05050fU, 0x2f9a9ab5U,
     79    0x0e070709U, 0x24121236U, 0x1b80809bU, 0xdfe2e23dU,
     80    0xcdebeb26U, 0x4e272769U, 0x7fb2b2cdU, 0xea75759fU,
     81    0x1209091bU, 0x1d83839eU, 0x582c2c74U, 0x341a1a2eU,
     82    0x361b1b2dU, 0xdc6e6eb2U, 0xb45a5aeeU, 0x5ba0a0fbU,
     83    0xa45252f6U, 0x763b3b4dU, 0xb7d6d661U, 0x7db3b3ceU,
     84    0x5229297bU, 0xdde3e33eU, 0x5e2f2f71U, 0x13848497U,
     85    0xa65353f5U, 0xb9d1d168U, 0x00000000U, 0xc1eded2cU,
     86    0x40202060U, 0xe3fcfc1fU, 0x79b1b1c8U, 0xb65b5bedU,
     87    0xd46a6abeU, 0x8dcbcb46U, 0x67bebed9U, 0x7239394bU,
     88    0x944a4adeU, 0x984c4cd4U, 0xb05858e8U, 0x85cfcf4aU,
     89    0xbbd0d06bU, 0xc5efef2aU, 0x4faaaae5U, 0xedfbfb16U,
     90    0x864343c5U, 0x9a4d4dd7U, 0x66333355U, 0x11858594U,
     91    0x8a4545cfU, 0xe9f9f910U, 0x04020206U, 0xfe7f7f81U,
     92    0xa05050f0U, 0x783c3c44U, 0x259f9fbaU, 0x4ba8a8e3U,
     93    0xa25151f3U, 0x5da3a3feU, 0x804040c0U, 0x058f8f8aU,
     94    0x3f9292adU, 0x219d9dbcU, 0x70383848U, 0xf1f5f504U,
     95    0x63bcbcdfU, 0x77b6b6c1U, 0xafdada75U, 0x42212163U,
     96    0x20101030U, 0xe5ffff1aU, 0xfdf3f30eU, 0xbfd2d26dU,
     97    0x81cdcd4cU, 0x180c0c14U, 0x26131335U, 0xc3ecec2fU,
     98    0xbe5f5fe1U, 0x359797a2U, 0x884444ccU, 0x2e171739U,
     99    0x93c4c457U, 0x55a7a7f2U, 0xfc7e7e82U, 0x7a3d3d47U,
     100    0xc86464acU, 0xba5d5de7U, 0x3219192bU, 0xe6737395U,
     101    0xc06060a0U, 0x19818198U, 0x9e4f4fd1U, 0xa3dcdc7fU,
     102    0x44222266U, 0x542a2a7eU, 0x3b9090abU, 0x0b888883U,
     103    0x8c4646caU, 0xc7eeee29U, 0x6bb8b8d3U, 0x2814143cU,
     104    0xa7dede79U, 0xbc5e5ee2U, 0x160b0b1dU, 0xaddbdb76U,
     105    0xdbe0e03bU, 0x64323256U, 0x743a3a4eU, 0x140a0a1eU,
     106    0x924949dbU, 0x0c06060aU, 0x4824246cU, 0xb85c5ce4U,
     107    0x9fc2c25dU, 0xbdd3d36eU, 0x43acacefU, 0xc46262a6U,
     108    0x399191a8U, 0x319595a4U, 0xd3e4e437U, 0xf279798bU,
     109    0xd5e7e732U, 0x8bc8c843U, 0x6e373759U, 0xda6d6db7U,
     110    0x018d8d8cU, 0xb1d5d564U, 0x9c4e4ed2U, 0x49a9a9e0U,
     111    0xd86c6cb4U, 0xac5656faU, 0xf3f4f407U, 0xcfeaea25U,
     112    0xca6565afU, 0xf47a7a8eU, 0x47aeaee9U, 0x10080818U,
     113    0x6fbabad5U, 0xf0787888U, 0x4a25256fU, 0x5c2e2e72U,
     114    0x381c1c24U, 0x57a6a6f1U, 0x73b4b4c7U, 0x97c6c651U,
     115    0xcbe8e823U, 0xa1dddd7cU, 0xe874749cU, 0x3e1f1f21U,
     116    0x964b4bddU, 0x61bdbddcU, 0x0d8b8b86U, 0x0f8a8a85U,
     117    0xe0707090U, 0x7c3e3e42U, 0x71b5b5c4U, 0xcc6666aaU,
     118    0x904848d8U, 0x06030305U, 0xf7f6f601U, 0x1c0e0e12U,
     119    0xc26161a3U, 0x6a35355fU, 0xae5757f9U, 0x69b9b9d0U,
     120    0x17868691U, 0x99c1c158U, 0x3a1d1d27U, 0x279e9eb9U,
     121    0xd9e1e138U, 0xebf8f813U, 0x2b9898b3U, 0x22111133U,
     122    0xd26969bbU, 0xa9d9d970U, 0x078e8e89U, 0x339494a7U,
     123    0x2d9b9bb6U, 0x3c1e1e22U, 0x15878792U, 0xc9e9e920U,
     124    0x87cece49U, 0xaa5555ffU, 0x50282878U, 0xa5dfdf7aU,
     125    0x038c8c8fU, 0x59a1a1f8U, 0x09898980U, 0x1a0d0d17U,
     126    0x65bfbfdaU, 0xd7e6e631U, 0x844242c6U, 0xd06868b8U,
     127    0x824141c3U, 0x299999b0U, 0x5a2d2d77U, 0x1e0f0f11U,
     128    0x7bb0b0cbU, 0xa85454fcU, 0x6dbbbbd6U, 0x2c16163aU,
     129};
     130static const u32 Te1[256] = {
     131    0xa5c66363U, 0x84f87c7cU, 0x99ee7777U, 0x8df67b7bU,
     132    0x0dfff2f2U, 0xbdd66b6bU, 0xb1de6f6fU, 0x5491c5c5U,
     133    0x50603030U, 0x03020101U, 0xa9ce6767U, 0x7d562b2bU,
     134    0x19e7fefeU, 0x62b5d7d7U, 0xe64dababU, 0x9aec7676U,
     135    0x458fcacaU, 0x9d1f8282U, 0x4089c9c9U, 0x87fa7d7dU,
     136    0x15effafaU, 0xebb25959U, 0xc98e4747U, 0x0bfbf0f0U,
     137    0xec41adadU, 0x67b3d4d4U, 0xfd5fa2a2U, 0xea45afafU,
     138    0xbf239c9cU, 0xf753a4a4U, 0x96e47272U, 0x5b9bc0c0U,
     139    0xc275b7b7U, 0x1ce1fdfdU, 0xae3d9393U, 0x6a4c2626U,
     140    0x5a6c3636U, 0x417e3f3fU, 0x02f5f7f7U, 0x4f83ccccU,
     141    0x5c683434U, 0xf451a5a5U, 0x34d1e5e5U, 0x08f9f1f1U,
     142    0x93e27171U, 0x73abd8d8U, 0x53623131U, 0x3f2a1515U,
     143    0x0c080404U, 0x5295c7c7U, 0x65462323U, 0x5e9dc3c3U,
     144    0x28301818U, 0xa1379696U, 0x0f0a0505U, 0xb52f9a9aU,
     145    0x090e0707U, 0x36241212U, 0x9b1b8080U, 0x3ddfe2e2U,
     146    0x26cdebebU, 0x694e2727U, 0xcd7fb2b2U, 0x9fea7575U,
     147    0x1b120909U, 0x9e1d8383U, 0x74582c2cU, 0x2e341a1aU,
     148    0x2d361b1bU, 0xb2dc6e6eU, 0xeeb45a5aU, 0xfb5ba0a0U,
     149    0xf6a45252U, 0x4d763b3bU, 0x61b7d6d6U, 0xce7db3b3U,
     150    0x7b522929U, 0x3edde3e3U, 0x715e2f2fU, 0x97138484U,
     151    0xf5a65353U, 0x68b9d1d1U, 0x00000000U, 0x2cc1ededU,
     152    0x60402020U, 0x1fe3fcfcU, 0xc879b1b1U, 0xedb65b5bU,
     153    0xbed46a6aU, 0x468dcbcbU, 0xd967bebeU, 0x4b723939U,
     154    0xde944a4aU, 0xd4984c4cU, 0xe8b05858U, 0x4a85cfcfU,
     155    0x6bbbd0d0U, 0x2ac5efefU, 0xe54faaaaU, 0x16edfbfbU,
     156    0xc5864343U, 0xd79a4d4dU, 0x55663333U, 0x94118585U,
     157    0xcf8a4545U, 0x10e9f9f9U, 0x06040202U, 0x81fe7f7fU,
     158    0xf0a05050U, 0x44783c3cU, 0xba259f9fU, 0xe34ba8a8U,
     159    0xf3a25151U, 0xfe5da3a3U, 0xc0804040U, 0x8a058f8fU,
     160    0xad3f9292U, 0xbc219d9dU, 0x48703838U, 0x04f1f5f5U,
     161    0xdf63bcbcU, 0xc177b6b6U, 0x75afdadaU, 0x63422121U,
     162    0x30201010U, 0x1ae5ffffU, 0x0efdf3f3U, 0x6dbfd2d2U,
     163    0x4c81cdcdU, 0x14180c0cU, 0x35261313U, 0x2fc3ececU,
     164    0xe1be5f5fU, 0xa2359797U, 0xcc884444U, 0x392e1717U,
     165    0x5793c4c4U, 0xf255a7a7U, 0x82fc7e7eU, 0x477a3d3dU,
     166    0xacc86464U, 0xe7ba5d5dU, 0x2b321919U, 0x95e67373U,
     167    0xa0c06060U, 0x98198181U, 0xd19e4f4fU, 0x7fa3dcdcU,
     168    0x66442222U, 0x7e542a2aU, 0xab3b9090U, 0x830b8888U,
     169    0xca8c4646U, 0x29c7eeeeU, 0xd36bb8b8U, 0x3c281414U,
     170    0x79a7dedeU, 0xe2bc5e5eU, 0x1d160b0bU, 0x76addbdbU,
     171    0x3bdbe0e0U, 0x56643232U, 0x4e743a3aU, 0x1e140a0aU,
     172    0xdb924949U, 0x0a0c0606U, 0x6c482424U, 0xe4b85c5cU,
     173    0x5d9fc2c2U, 0x6ebdd3d3U, 0xef43acacU, 0xa6c46262U,
     174    0xa8399191U, 0xa4319595U, 0x37d3e4e4U, 0x8bf27979U,
     175    0x32d5e7e7U, 0x438bc8c8U, 0x596e3737U, 0xb7da6d6dU,
     176    0x8c018d8dU, 0x64b1d5d5U, 0xd29c4e4eU, 0xe049a9a9U,
     177    0xb4d86c6cU, 0xfaac5656U, 0x07f3f4f4U, 0x25cfeaeaU,
     178    0xafca6565U, 0x8ef47a7aU, 0xe947aeaeU, 0x18100808U,
     179    0xd56fbabaU, 0x88f07878U, 0x6f4a2525U, 0x725c2e2eU,
     180    0x24381c1cU, 0xf157a6a6U, 0xc773b4b4U, 0x5197c6c6U,
     181    0x23cbe8e8U, 0x7ca1ddddU, 0x9ce87474U, 0x213e1f1fU,
     182    0xdd964b4bU, 0xdc61bdbdU, 0x860d8b8bU, 0x850f8a8aU,
     183    0x90e07070U, 0x427c3e3eU, 0xc471b5b5U, 0xaacc6666U,
     184    0xd8904848U, 0x05060303U, 0x01f7f6f6U, 0x121c0e0eU,
     185    0xa3c26161U, 0x5f6a3535U, 0xf9ae5757U, 0xd069b9b9U,
     186    0x91178686U, 0x5899c1c1U, 0x273a1d1dU, 0xb9279e9eU,
     187    0x38d9e1e1U, 0x13ebf8f8U, 0xb32b9898U, 0x33221111U,
     188    0xbbd26969U, 0x70a9d9d9U, 0x89078e8eU, 0xa7339494U,
     189    0xb62d9b9bU, 0x223c1e1eU, 0x92158787U, 0x20c9e9e9U,
     190    0x4987ceceU, 0xffaa5555U, 0x78502828U, 0x7aa5dfdfU,
     191    0x8f038c8cU, 0xf859a1a1U, 0x80098989U, 0x171a0d0dU,
     192    0xda65bfbfU, 0x31d7e6e6U, 0xc6844242U, 0xb8d06868U,
     193    0xc3824141U, 0xb0299999U, 0x775a2d2dU, 0x111e0f0fU,
     194    0xcb7bb0b0U, 0xfca85454U, 0xd66dbbbbU, 0x3a2c1616U,
     195};
     196static const u32 Te2[256] = {
     197    0x63a5c663U, 0x7c84f87cU, 0x7799ee77U, 0x7b8df67bU,
     198    0xf20dfff2U, 0x6bbdd66bU, 0x6fb1de6fU, 0xc55491c5U,
     199    0x30506030U, 0x01030201U, 0x67a9ce67U, 0x2b7d562bU,
     200    0xfe19e7feU, 0xd762b5d7U, 0xabe64dabU, 0x769aec76U,
     201    0xca458fcaU, 0x829d1f82U, 0xc94089c9U, 0x7d87fa7dU,
     202    0xfa15effaU, 0x59ebb259U, 0x47c98e47U, 0xf00bfbf0U,
     203    0xadec41adU, 0xd467b3d4U, 0xa2fd5fa2U, 0xafea45afU,
     204    0x9cbf239cU, 0xa4f753a4U, 0x7296e472U, 0xc05b9bc0U,
     205    0xb7c275b7U, 0xfd1ce1fdU, 0x93ae3d93U, 0x266a4c26U,
     206    0x365a6c36U, 0x3f417e3fU, 0xf702f5f7U, 0xcc4f83ccU,
     207    0x345c6834U, 0xa5f451a5U, 0xe534d1e5U, 0xf108f9f1U,
     208    0x7193e271U, 0xd873abd8U, 0x31536231U, 0x153f2a15U,
     209    0x040c0804U, 0xc75295c7U, 0x23654623U, 0xc35e9dc3U,
     210    0x18283018U, 0x96a13796U, 0x050f0a05U, 0x9ab52f9aU,
     211    0x07090e07U, 0x12362412U, 0x809b1b80U, 0xe23ddfe2U,
     212    0xeb26cdebU, 0x27694e27U, 0xb2cd7fb2U, 0x759fea75U,
     213    0x091b1209U, 0x839e1d83U, 0x2c74582cU, 0x1a2e341aU,
     214    0x1b2d361bU, 0x6eb2dc6eU, 0x5aeeb45aU, 0xa0fb5ba0U,
     215    0x52f6a452U, 0x3b4d763bU, 0xd661b7d6U, 0xb3ce7db3U,
     216    0x297b5229U, 0xe33edde3U, 0x2f715e2fU, 0x84971384U,
     217    0x53f5a653U, 0xd168b9d1U, 0x00000000U, 0xed2cc1edU,
     218    0x20604020U, 0xfc1fe3fcU, 0xb1c879b1U, 0x5bedb65bU,
     219    0x6abed46aU, 0xcb468dcbU, 0xbed967beU, 0x394b7239U,
     220    0x4ade944aU, 0x4cd4984cU, 0x58e8b058U, 0xcf4a85cfU,
     221    0xd06bbbd0U, 0xef2ac5efU, 0xaae54faaU, 0xfb16edfbU,
     222    0x43c58643U, 0x4dd79a4dU, 0x33556633U, 0x85941185U,
     223    0x45cf8a45U, 0xf910e9f9U, 0x02060402U, 0x7f81fe7fU,
     224    0x50f0a050U, 0x3c44783cU, 0x9fba259fU, 0xa8e34ba8U,
     225    0x51f3a251U, 0xa3fe5da3U, 0x40c08040U, 0x8f8a058fU,
     226    0x92ad3f92U, 0x9dbc219dU, 0x38487038U, 0xf504f1f5U,
     227    0xbcdf63bcU, 0xb6c177b6U, 0xda75afdaU, 0x21634221U,
     228    0x10302010U, 0xff1ae5ffU, 0xf30efdf3U, 0xd26dbfd2U,
     229    0xcd4c81cdU, 0x0c14180cU, 0x13352613U, 0xec2fc3ecU,
     230    0x5fe1be5fU, 0x97a23597U, 0x44cc8844U, 0x17392e17U,
     231    0xc45793c4U, 0xa7f255a7U, 0x7e82fc7eU, 0x3d477a3dU,
     232    0x64acc864U, 0x5de7ba5dU, 0x192b3219U, 0x7395e673U,
     233    0x60a0c060U, 0x81981981U, 0x4fd19e4fU, 0xdc7fa3dcU,
     234    0x22664422U, 0x2a7e542aU, 0x90ab3b90U, 0x88830b88U,
     235    0x46ca8c46U, 0xee29c7eeU, 0xb8d36bb8U, 0x143c2814U,
     236    0xde79a7deU, 0x5ee2bc5eU, 0x0b1d160bU, 0xdb76addbU,
     237    0xe03bdbe0U, 0x32566432U, 0x3a4e743aU, 0x0a1e140aU,
     238    0x49db9249U, 0x060a0c06U, 0x246c4824U, 0x5ce4b85cU,
     239    0xc25d9fc2U, 0xd36ebdd3U, 0xacef43acU, 0x62a6c462U,
     240    0x91a83991U, 0x95a43195U, 0xe437d3e4U, 0x798bf279U,
     241    0xe732d5e7U, 0xc8438bc8U, 0x37596e37U, 0x6db7da6dU,
     242    0x8d8c018dU, 0xd564b1d5U, 0x4ed29c4eU, 0xa9e049a9U,
     243    0x6cb4d86cU, 0x56faac56U, 0xf407f3f4U, 0xea25cfeaU,
     244    0x65afca65U, 0x7a8ef47aU, 0xaee947aeU, 0x08181008U,
     245    0xbad56fbaU, 0x7888f078U, 0x256f4a25U, 0x2e725c2eU,
     246    0x1c24381cU, 0xa6f157a6U, 0xb4c773b4U, 0xc65197c6U,
     247    0xe823cbe8U, 0xdd7ca1ddU, 0x749ce874U, 0x1f213e1fU,
     248    0x4bdd964bU, 0xbddc61bdU, 0x8b860d8bU, 0x8a850f8aU,
     249    0x7090e070U, 0x3e427c3eU, 0xb5c471b5U, 0x66aacc66U,
     250    0x48d89048U, 0x03050603U, 0xf601f7f6U, 0x0e121c0eU,
     251    0x61a3c261U, 0x355f6a35U, 0x57f9ae57U, 0xb9d069b9U,
     252    0x86911786U, 0xc15899c1U, 0x1d273a1dU, 0x9eb9279eU,
     253    0xe138d9e1U, 0xf813ebf8U, 0x98b32b98U, 0x11332211U,
     254    0x69bbd269U, 0xd970a9d9U, 0x8e89078eU, 0x94a73394U,
     255    0x9bb62d9bU, 0x1e223c1eU, 0x87921587U, 0xe920c9e9U,
     256    0xce4987ceU, 0x55ffaa55U, 0x28785028U, 0xdf7aa5dfU,
     257    0x8c8f038cU, 0xa1f859a1U, 0x89800989U, 0x0d171a0dU,
     258    0xbfda65bfU, 0xe631d7e6U, 0x42c68442U, 0x68b8d068U,
     259    0x41c38241U, 0x99b02999U, 0x2d775a2dU, 0x0f111e0fU,
     260    0xb0cb7bb0U, 0x54fca854U, 0xbbd66dbbU, 0x163a2c16U,
     261};
     262static const u32 Te3[256] = {
     263
     264    0x6363a5c6U, 0x7c7c84f8U, 0x777799eeU, 0x7b7b8df6U,
     265    0xf2f20dffU, 0x6b6bbdd6U, 0x6f6fb1deU, 0xc5c55491U,
     266    0x30305060U, 0x01010302U, 0x6767a9ceU, 0x2b2b7d56U,
     267    0xfefe19e7U, 0xd7d762b5U, 0xababe64dU, 0x76769aecU,
     268    0xcaca458fU, 0x82829d1fU, 0xc9c94089U, 0x7d7d87faU,
     269    0xfafa15efU, 0x5959ebb2U, 0x4747c98eU, 0xf0f00bfbU,
     270    0xadadec41U, 0xd4d467b3U, 0xa2a2fd5fU, 0xafafea45U,
     271    0x9c9cbf23U, 0xa4a4f753U, 0x727296e4U, 0xc0c05b9bU,
     272    0xb7b7c275U, 0xfdfd1ce1U, 0x9393ae3dU, 0x26266a4cU,
     273    0x36365a6cU, 0x3f3f417eU, 0xf7f702f5U, 0xcccc4f83U,
     274    0x34345c68U, 0xa5a5f451U, 0xe5e534d1U, 0xf1f108f9U,
     275    0x717193e2U, 0xd8d873abU, 0x31315362U, 0x15153f2aU,
     276    0x04040c08U, 0xc7c75295U, 0x23236546U, 0xc3c35e9dU,
     277    0x18182830U, 0x9696a137U, 0x05050f0aU, 0x9a9ab52fU,
     278    0x0707090eU, 0x12123624U, 0x80809b1bU, 0xe2e23ddfU,
     279    0xebeb26cdU, 0x2727694eU, 0xb2b2cd7fU, 0x75759feaU,
     280    0x09091b12U, 0x83839e1dU, 0x2c2c7458U, 0x1a1a2e34U,
     281    0x1b1b2d36U, 0x6e6eb2dcU, 0x5a5aeeb4U, 0xa0a0fb5bU,
     282    0x5252f6a4U, 0x3b3b4d76U, 0xd6d661b7U, 0xb3b3ce7dU,
     283    0x29297b52U, 0xe3e33eddU, 0x2f2f715eU, 0x84849713U,
     284    0x5353f5a6U, 0xd1d168b9U, 0x00000000U, 0xeded2cc1U,
     285    0x20206040U, 0xfcfc1fe3U, 0xb1b1c879U, 0x5b5bedb6U,
     286    0x6a6abed4U, 0xcbcb468dU, 0xbebed967U, 0x39394b72U,
     287    0x4a4ade94U, 0x4c4cd498U, 0x5858e8b0U, 0xcfcf4a85U,
     288    0xd0d06bbbU, 0xefef2ac5U, 0xaaaae54fU, 0xfbfb16edU,
     289    0x4343c586U, 0x4d4dd79aU, 0x33335566U, 0x85859411U,
     290    0x4545cf8aU, 0xf9f910e9U, 0x02020604U, 0x7f7f81feU,
     291    0x5050f0a0U, 0x3c3c4478U, 0x9f9fba25U, 0xa8a8e34bU,
     292    0x5151f3a2U, 0xa3a3fe5dU, 0x4040c080U, 0x8f8f8a05U,
     293    0x9292ad3fU, 0x9d9dbc21U, 0x38384870U, 0xf5f504f1U,
     294    0xbcbcdf63U, 0xb6b6c177U, 0xdada75afU, 0x21216342U,
     295    0x10103020U, 0xffff1ae5U, 0xf3f30efdU, 0xd2d26dbfU,
     296    0xcdcd4c81U, 0x0c0c1418U, 0x13133526U, 0xecec2fc3U,
     297    0x5f5fe1beU, 0x9797a235U, 0x4444cc88U, 0x1717392eU,
     298    0xc4c45793U, 0xa7a7f255U, 0x7e7e82fcU, 0x3d3d477aU,
     299    0x6464acc8U, 0x5d5de7baU, 0x19192b32U, 0x737395e6U,
     300    0x6060a0c0U, 0x81819819U, 0x4f4fd19eU, 0xdcdc7fa3U,
     301    0x22226644U, 0x2a2a7e54U, 0x9090ab3bU, 0x8888830bU,
     302    0x4646ca8cU, 0xeeee29c7U, 0xb8b8d36bU, 0x14143c28U,
     303    0xdede79a7U, 0x5e5ee2bcU, 0x0b0b1d16U, 0xdbdb76adU,
     304    0xe0e03bdbU, 0x32325664U, 0x3a3a4e74U, 0x0a0a1e14U,
     305    0x4949db92U, 0x06060a0cU, 0x24246c48U, 0x5c5ce4b8U,
     306    0xc2c25d9fU, 0xd3d36ebdU, 0xacacef43U, 0x6262a6c4U,
     307    0x9191a839U, 0x9595a431U, 0xe4e437d3U, 0x79798bf2U,
     308    0xe7e732d5U, 0xc8c8438bU, 0x3737596eU, 0x6d6db7daU,
     309    0x8d8d8c01U, 0xd5d564b1U, 0x4e4ed29cU, 0xa9a9e049U,
     310    0x6c6cb4d8U, 0x5656faacU, 0xf4f407f3U, 0xeaea25cfU,
     311    0x6565afcaU, 0x7a7a8ef4U, 0xaeaee947U, 0x08081810U,
     312    0xbabad56fU, 0x787888f0U, 0x25256f4aU, 0x2e2e725cU,
     313    0x1c1c2438U, 0xa6a6f157U, 0xb4b4c773U, 0xc6c65197U,
     314    0xe8e823cbU, 0xdddd7ca1U, 0x74749ce8U, 0x1f1f213eU,
     315    0x4b4bdd96U, 0xbdbddc61U, 0x8b8b860dU, 0x8a8a850fU,
     316    0x707090e0U, 0x3e3e427cU, 0xb5b5c471U, 0x6666aaccU,
     317    0x4848d890U, 0x03030506U, 0xf6f601f7U, 0x0e0e121cU,
     318    0x6161a3c2U, 0x35355f6aU, 0x5757f9aeU, 0xb9b9d069U,
     319    0x86869117U, 0xc1c15899U, 0x1d1d273aU, 0x9e9eb927U,
     320    0xe1e138d9U, 0xf8f813ebU, 0x9898b32bU, 0x11113322U,
     321    0x6969bbd2U, 0xd9d970a9U, 0x8e8e8907U, 0x9494a733U,
     322    0x9b9bb62dU, 0x1e1e223cU, 0x87879215U, 0xe9e920c9U,
     323    0xcece4987U, 0x5555ffaaU, 0x28287850U, 0xdfdf7aa5U,
     324    0x8c8c8f03U, 0xa1a1f859U, 0x89898009U, 0x0d0d171aU,
     325    0xbfbfda65U, 0xe6e631d7U, 0x4242c684U, 0x6868b8d0U,
     326    0x4141c382U, 0x9999b029U, 0x2d2d775aU, 0x0f0f111eU,
     327    0xb0b0cb7bU, 0x5454fca8U, 0xbbbbd66dU, 0x16163a2cU,
     328};
     329static const u32 Te4[256] = {
     330    0x63636363U, 0x7c7c7c7cU, 0x77777777U, 0x7b7b7b7bU,
     331    0xf2f2f2f2U, 0x6b6b6b6bU, 0x6f6f6f6fU, 0xc5c5c5c5U,
     332    0x30303030U, 0x01010101U, 0x67676767U, 0x2b2b2b2bU,
     333    0xfefefefeU, 0xd7d7d7d7U, 0xababababU, 0x76767676U,
     334    0xcacacacaU, 0x82828282U, 0xc9c9c9c9U, 0x7d7d7d7dU,
     335    0xfafafafaU, 0x59595959U, 0x47474747U, 0xf0f0f0f0U,
     336    0xadadadadU, 0xd4d4d4d4U, 0xa2a2a2a2U, 0xafafafafU,
     337    0x9c9c9c9cU, 0xa4a4a4a4U, 0x72727272U, 0xc0c0c0c0U,
     338    0xb7b7b7b7U, 0xfdfdfdfdU, 0x93939393U, 0x26262626U,
     339    0x36363636U, 0x3f3f3f3fU, 0xf7f7f7f7U, 0xccccccccU,
     340    0x34343434U, 0xa5a5a5a5U, 0xe5e5e5e5U, 0xf1f1f1f1U,
     341    0x71717171U, 0xd8d8d8d8U, 0x31313131U, 0x15151515U,
     342    0x04040404U, 0xc7c7c7c7U, 0x23232323U, 0xc3c3c3c3U,
     343    0x18181818U, 0x96969696U, 0x05050505U, 0x9a9a9a9aU,
     344    0x07070707U, 0x12121212U, 0x80808080U, 0xe2e2e2e2U,
     345    0xebebebebU, 0x27272727U, 0xb2b2b2b2U, 0x75757575U,
     346    0x09090909U, 0x83838383U, 0x2c2c2c2cU, 0x1a1a1a1aU,
     347    0x1b1b1b1bU, 0x6e6e6e6eU, 0x5a5a5a5aU, 0xa0a0a0a0U,
     348    0x52525252U, 0x3b3b3b3bU, 0xd6d6d6d6U, 0xb3b3b3b3U,
     349    0x29292929U, 0xe3e3e3e3U, 0x2f2f2f2fU, 0x84848484U,
     350    0x53535353U, 0xd1d1d1d1U, 0x00000000U, 0xededededU,
     351    0x20202020U, 0xfcfcfcfcU, 0xb1b1b1b1U, 0x5b5b5b5bU,
     352    0x6a6a6a6aU, 0xcbcbcbcbU, 0xbebebebeU, 0x39393939U,
     353    0x4a4a4a4aU, 0x4c4c4c4cU, 0x58585858U, 0xcfcfcfcfU,
     354    0xd0d0d0d0U, 0xefefefefU, 0xaaaaaaaaU, 0xfbfbfbfbU,
     355    0x43434343U, 0x4d4d4d4dU, 0x33333333U, 0x85858585U,
     356    0x45454545U, 0xf9f9f9f9U, 0x02020202U, 0x7f7f7f7fU,
     357    0x50505050U, 0x3c3c3c3cU, 0x9f9f9f9fU, 0xa8a8a8a8U,
     358    0x51515151U, 0xa3a3a3a3U, 0x40404040U, 0x8f8f8f8fU,
     359    0x92929292U, 0x9d9d9d9dU, 0x38383838U, 0xf5f5f5f5U,
     360    0xbcbcbcbcU, 0xb6b6b6b6U, 0xdadadadaU, 0x21212121U,
     361    0x10101010U, 0xffffffffU, 0xf3f3f3f3U, 0xd2d2d2d2U,
     362    0xcdcdcdcdU, 0x0c0c0c0cU, 0x13131313U, 0xececececU,
     363    0x5f5f5f5fU, 0x97979797U, 0x44444444U, 0x17171717U,
     364    0xc4c4c4c4U, 0xa7a7a7a7U, 0x7e7e7e7eU, 0x3d3d3d3dU,
     365    0x64646464U, 0x5d5d5d5dU, 0x19191919U, 0x73737373U,
     366    0x60606060U, 0x81818181U, 0x4f4f4f4fU, 0xdcdcdcdcU,
     367    0x22222222U, 0x2a2a2a2aU, 0x90909090U, 0x88888888U,
     368    0x46464646U, 0xeeeeeeeeU, 0xb8b8b8b8U, 0x14141414U,
     369    0xdedededeU, 0x5e5e5e5eU, 0x0b0b0b0bU, 0xdbdbdbdbU,
     370    0xe0e0e0e0U, 0x32323232U, 0x3a3a3a3aU, 0x0a0a0a0aU,
     371    0x49494949U, 0x06060606U, 0x24242424U, 0x5c5c5c5cU,
     372    0xc2c2c2c2U, 0xd3d3d3d3U, 0xacacacacU, 0x62626262U,
     373    0x91919191U, 0x95959595U, 0xe4e4e4e4U, 0x79797979U,
     374    0xe7e7e7e7U, 0xc8c8c8c8U, 0x37373737U, 0x6d6d6d6dU,
     375    0x8d8d8d8dU, 0xd5d5d5d5U, 0x4e4e4e4eU, 0xa9a9a9a9U,
     376    0x6c6c6c6cU, 0x56565656U, 0xf4f4f4f4U, 0xeaeaeaeaU,
     377    0x65656565U, 0x7a7a7a7aU, 0xaeaeaeaeU, 0x08080808U,
     378    0xbabababaU, 0x78787878U, 0x25252525U, 0x2e2e2e2eU,
     379    0x1c1c1c1cU, 0xa6a6a6a6U, 0xb4b4b4b4U, 0xc6c6c6c6U,
     380    0xe8e8e8e8U, 0xddddddddU, 0x74747474U, 0x1f1f1f1fU,
     381    0x4b4b4b4bU, 0xbdbdbdbdU, 0x8b8b8b8bU, 0x8a8a8a8aU,
     382    0x70707070U, 0x3e3e3e3eU, 0xb5b5b5b5U, 0x66666666U,
     383    0x48484848U, 0x03030303U, 0xf6f6f6f6U, 0x0e0e0e0eU,
     384    0x61616161U, 0x35353535U, 0x57575757U, 0xb9b9b9b9U,
     385    0x86868686U, 0xc1c1c1c1U, 0x1d1d1d1dU, 0x9e9e9e9eU,
     386    0xe1e1e1e1U, 0xf8f8f8f8U, 0x98989898U, 0x11111111U,
     387    0x69696969U, 0xd9d9d9d9U, 0x8e8e8e8eU, 0x94949494U,
     388    0x9b9b9b9bU, 0x1e1e1e1eU, 0x87878787U, 0xe9e9e9e9U,
     389    0xcecececeU, 0x55555555U, 0x28282828U, 0xdfdfdfdfU,
     390    0x8c8c8c8cU, 0xa1a1a1a1U, 0x89898989U, 0x0d0d0d0dU,
     391    0xbfbfbfbfU, 0xe6e6e6e6U, 0x42424242U, 0x68686868U,
     392    0x41414141U, 0x99999999U, 0x2d2d2d2dU, 0x0f0f0f0fU,
     393    0xb0b0b0b0U, 0x54545454U, 0xbbbbbbbbU, 0x16161616U,
     394};
     395static const u32 Td0[256] = {
     396    0x51f4a750U, 0x7e416553U, 0x1a17a4c3U, 0x3a275e96U,
     397    0x3bab6bcbU, 0x1f9d45f1U, 0xacfa58abU, 0x4be30393U,
     398    0x2030fa55U, 0xad766df6U, 0x88cc7691U, 0xf5024c25U,
     399    0x4fe5d7fcU, 0xc52acbd7U, 0x26354480U, 0xb562a38fU,
     400    0xdeb15a49U, 0x25ba1b67U, 0x45ea0e98U, 0x5dfec0e1U,
     401    0xc32f7502U, 0x814cf012U, 0x8d4697a3U, 0x6bd3f9c6U,
     402    0x038f5fe7U, 0x15929c95U, 0xbf6d7aebU, 0x955259daU,
     403    0xd4be832dU, 0x587421d3U, 0x49e06929U, 0x8ec9c844U,
     404    0x75c2896aU, 0xf48e7978U, 0x99583e6bU, 0x27b971ddU,
     405    0xbee14fb6U, 0xf088ad17U, 0xc920ac66U, 0x7dce3ab4U,
     406    0x63df4a18U, 0xe51a3182U, 0x97513360U, 0x62537f45U,
     407    0xb16477e0U, 0xbb6bae84U, 0xfe81a01cU, 0xf9082b94U,
     408    0x70486858U, 0x8f45fd19U, 0x94de6c87U, 0x527bf8b7U,
     409    0xab73d323U, 0x724b02e2U, 0xe31f8f57U, 0x6655ab2aU,
     410    0xb2eb2807U, 0x2fb5c203U, 0x86c57b9aU, 0xd33708a5U,
     411    0x302887f2U, 0x23bfa5b2U, 0x02036abaU, 0xed16825cU,
     412    0x8acf1c2bU, 0xa779b492U, 0xf307f2f0U, 0x4e69e2a1U,
     413    0x65daf4cdU, 0x0605bed5U, 0xd134621fU, 0xc4a6fe8aU,
     414    0x342e539dU, 0xa2f355a0U, 0x058ae132U, 0xa4f6eb75U,
     415    0x0b83ec39U, 0x4060efaaU, 0x5e719f06U, 0xbd6e1051U,
     416    0x3e218af9U, 0x96dd063dU, 0xdd3e05aeU, 0x4de6bd46U,
     417    0x91548db5U, 0x71c45d05U, 0x0406d46fU, 0x605015ffU,
     418    0x1998fb24U, 0xd6bde997U, 0x894043ccU, 0x67d99e77U,
     419    0xb0e842bdU, 0x07898b88U, 0xe7195b38U, 0x79c8eedbU,
     420    0xa17c0a47U, 0x7c420fe9U, 0xf8841ec9U, 0x00000000U,
     421    0x09808683U, 0x322bed48U, 0x1e1170acU, 0x6c5a724eU,
     422    0xfd0efffbU, 0x0f853856U, 0x3daed51eU, 0x362d3927U,
     423    0x0a0fd964U, 0x685ca621U, 0x9b5b54d1U, 0x24362e3aU,
     424    0x0c0a67b1U, 0x9357e70fU, 0xb4ee96d2U, 0x1b9b919eU,
     425    0x80c0c54fU, 0x61dc20a2U, 0x5a774b69U, 0x1c121a16U,
     426    0xe293ba0aU, 0xc0a02ae5U, 0x3c22e043U, 0x121b171dU,
     427    0x0e090d0bU, 0xf28bc7adU, 0x2db6a8b9U, 0x141ea9c8U,
     428    0x57f11985U, 0xaf75074cU, 0xee99ddbbU, 0xa37f60fdU,
     429    0xf701269fU, 0x5c72f5bcU, 0x44663bc5U, 0x5bfb7e34U,
     430    0x8b432976U, 0xcb23c6dcU, 0xb6edfc68U, 0xb8e4f163U,
     431    0xd731dccaU, 0x42638510U, 0x13972240U, 0x84c61120U,
     432    0x854a247dU, 0xd2bb3df8U, 0xaef93211U, 0xc729a16dU,
     433    0x1d9e2f4bU, 0xdcb230f3U, 0x0d8652ecU, 0x77c1e3d0U,
     434    0x2bb3166cU, 0xa970b999U, 0x119448faU, 0x47e96422U,
     435    0xa8fc8cc4U, 0xa0f03f1aU, 0x567d2cd8U, 0x223390efU,
     436    0x87494ec7U, 0xd938d1c1U, 0x8ccaa2feU, 0x98d40b36U,
     437    0xa6f581cfU, 0xa57ade28U, 0xdab78e26U, 0x3fadbfa4U,
     438    0x2c3a9de4U, 0x5078920dU, 0x6a5fcc9bU, 0x547e4662U,
     439    0xf68d13c2U, 0x90d8b8e8U, 0x2e39f75eU, 0x82c3aff5U,
     440    0x9f5d80beU, 0x69d0937cU, 0x6fd52da9U, 0xcf2512b3U,
     441    0xc8ac993bU, 0x10187da7U, 0xe89c636eU, 0xdb3bbb7bU,
     442    0xcd267809U, 0x6e5918f4U, 0xec9ab701U, 0x834f9aa8U,
     443    0xe6956e65U, 0xaaffe67eU, 0x21bccf08U, 0xef15e8e6U,
     444    0xbae79bd9U, 0x4a6f36ceU, 0xea9f09d4U, 0x29b07cd6U,
     445    0x31a4b2afU, 0x2a3f2331U, 0xc6a59430U, 0x35a266c0U,
     446    0x744ebc37U, 0xfc82caa6U, 0xe090d0b0U, 0x33a7d815U,
     447    0xf104984aU, 0x41ecdaf7U, 0x7fcd500eU, 0x1791f62fU,
     448    0x764dd68dU, 0x43efb04dU, 0xccaa4d54U, 0xe49604dfU,
     449    0x9ed1b5e3U, 0x4c6a881bU, 0xc12c1fb8U, 0x4665517fU,
     450    0x9d5eea04U, 0x018c355dU, 0xfa877473U, 0xfb0b412eU,
     451    0xb3671d5aU, 0x92dbd252U, 0xe9105633U, 0x6dd64713U,
     452    0x9ad7618cU, 0x37a10c7aU, 0x59f8148eU, 0xeb133c89U,
     453    0xcea927eeU, 0xb761c935U, 0xe11ce5edU, 0x7a47b13cU,
     454    0x9cd2df59U, 0x55f2733fU, 0x1814ce79U, 0x73c737bfU,
     455    0x53f7cdeaU, 0x5ffdaa5bU, 0xdf3d6f14U, 0x7844db86U,
     456    0xcaaff381U, 0xb968c43eU, 0x3824342cU, 0xc2a3405fU,
     457    0x161dc372U, 0xbce2250cU, 0x283c498bU, 0xff0d9541U,
     458    0x39a80171U, 0x080cb3deU, 0xd8b4e49cU, 0x6456c190U,
     459    0x7bcb8461U, 0xd532b670U, 0x486c5c74U, 0xd0b85742U,
     460};
     461static const u32 Td1[256] = {
     462    0x5051f4a7U, 0x537e4165U, 0xc31a17a4U, 0x963a275eU,
     463    0xcb3bab6bU, 0xf11f9d45U, 0xabacfa58U, 0x934be303U,
     464    0x552030faU, 0xf6ad766dU, 0x9188cc76U, 0x25f5024cU,
     465    0xfc4fe5d7U, 0xd7c52acbU, 0x80263544U, 0x8fb562a3U,
     466    0x49deb15aU, 0x6725ba1bU, 0x9845ea0eU, 0xe15dfec0U,
     467    0x02c32f75U, 0x12814cf0U, 0xa38d4697U, 0xc66bd3f9U,
     468    0xe7038f5fU, 0x9515929cU, 0xebbf6d7aU, 0xda955259U,
     469    0x2dd4be83U, 0xd3587421U, 0x2949e069U, 0x448ec9c8U,
     470    0x6a75c289U, 0x78f48e79U, 0x6b99583eU, 0xdd27b971U,
     471    0xb6bee14fU, 0x17f088adU, 0x66c920acU, 0xb47dce3aU,
     472    0x1863df4aU, 0x82e51a31U, 0x60975133U, 0x4562537fU,
     473    0xe0b16477U, 0x84bb6baeU, 0x1cfe81a0U, 0x94f9082bU,
     474    0x58704868U, 0x198f45fdU, 0x8794de6cU, 0xb7527bf8U,
     475    0x23ab73d3U, 0xe2724b02U, 0x57e31f8fU, 0x2a6655abU,
     476    0x07b2eb28U, 0x032fb5c2U, 0x9a86c57bU, 0xa5d33708U,
     477    0xf2302887U, 0xb223bfa5U, 0xba02036aU, 0x5ced1682U,
     478    0x2b8acf1cU, 0x92a779b4U, 0xf0f307f2U, 0xa14e69e2U,
     479    0xcd65daf4U, 0xd50605beU, 0x1fd13462U, 0x8ac4a6feU,
     480    0x9d342e53U, 0xa0a2f355U, 0x32058ae1U, 0x75a4f6ebU,
     481    0x390b83ecU, 0xaa4060efU, 0x065e719fU, 0x51bd6e10U,
     482    0xf93e218aU, 0x3d96dd06U, 0xaedd3e05U, 0x464de6bdU,
     483    0xb591548dU, 0x0571c45dU, 0x6f0406d4U, 0xff605015U,
     484    0x241998fbU, 0x97d6bde9U, 0xcc894043U, 0x7767d99eU,
     485    0xbdb0e842U, 0x8807898bU, 0x38e7195bU, 0xdb79c8eeU,
     486    0x47a17c0aU, 0xe97c420fU, 0xc9f8841eU, 0x00000000U,
     487    0x83098086U, 0x48322bedU, 0xac1e1170U, 0x4e6c5a72U,
     488    0xfbfd0effU, 0x560f8538U, 0x1e3daed5U, 0x27362d39U,
     489    0x640a0fd9U, 0x21685ca6U, 0xd19b5b54U, 0x3a24362eU,
     490    0xb10c0a67U, 0x0f9357e7U, 0xd2b4ee96U, 0x9e1b9b91U,
     491    0x4f80c0c5U, 0xa261dc20U, 0x695a774bU, 0x161c121aU,
     492    0x0ae293baU, 0xe5c0a02aU, 0x433c22e0U, 0x1d121b17U,
     493    0x0b0e090dU, 0xadf28bc7U, 0xb92db6a8U, 0xc8141ea9U,
     494    0x8557f119U, 0x4caf7507U, 0xbbee99ddU, 0xfda37f60U,
     495    0x9ff70126U, 0xbc5c72f5U, 0xc544663bU, 0x345bfb7eU,
     496    0x768b4329U, 0xdccb23c6U, 0x68b6edfcU, 0x63b8e4f1U,
     497    0xcad731dcU, 0x10426385U, 0x40139722U, 0x2084c611U,
     498    0x7d854a24U, 0xf8d2bb3dU, 0x11aef932U, 0x6dc729a1U,
     499    0x4b1d9e2fU, 0xf3dcb230U, 0xec0d8652U, 0xd077c1e3U,
     500    0x6c2bb316U, 0x99a970b9U, 0xfa119448U, 0x2247e964U,
     501    0xc4a8fc8cU, 0x1aa0f03fU, 0xd8567d2cU, 0xef223390U,
     502    0xc787494eU, 0xc1d938d1U, 0xfe8ccaa2U, 0x3698d40bU,
     503    0xcfa6f581U, 0x28a57adeU, 0x26dab78eU, 0xa43fadbfU,
     504    0xe42c3a9dU, 0x0d507892U, 0x9b6a5fccU, 0x62547e46U,
     505    0xc2f68d13U, 0xe890d8b8U, 0x5e2e39f7U, 0xf582c3afU,
     506    0xbe9f5d80U, 0x7c69d093U, 0xa96fd52dU, 0xb3cf2512U,
     507    0x3bc8ac99U, 0xa710187dU, 0x6ee89c63U, 0x7bdb3bbbU,
     508    0x09cd2678U, 0xf46e5918U, 0x01ec9ab7U, 0xa8834f9aU,
     509    0x65e6956eU, 0x7eaaffe6U, 0x0821bccfU, 0xe6ef15e8U,
     510    0xd9bae79bU, 0xce4a6f36U, 0xd4ea9f09U, 0xd629b07cU,
     511    0xaf31a4b2U, 0x312a3f23U, 0x30c6a594U, 0xc035a266U,
     512    0x37744ebcU, 0xa6fc82caU, 0xb0e090d0U, 0x1533a7d8U,
     513    0x4af10498U, 0xf741ecdaU, 0x0e7fcd50U, 0x2f1791f6U,
     514    0x8d764dd6U, 0x4d43efb0U, 0x54ccaa4dU, 0xdfe49604U,
     515    0xe39ed1b5U, 0x1b4c6a88U, 0xb8c12c1fU, 0x7f466551U,
     516    0x049d5eeaU, 0x5d018c35U, 0x73fa8774U, 0x2efb0b41U,
     517    0x5ab3671dU, 0x5292dbd2U, 0x33e91056U, 0x136dd647U,
     518    0x8c9ad761U, 0x7a37a10cU, 0x8e59f814U, 0x89eb133cU,
     519    0xeecea927U, 0x35b761c9U, 0xede11ce5U, 0x3c7a47b1U,
     520    0x599cd2dfU, 0x3f55f273U, 0x791814ceU, 0xbf73c737U,
     521    0xea53f7cdU, 0x5b5ffdaaU, 0x14df3d6fU, 0x867844dbU,
     522    0x81caaff3U, 0x3eb968c4U, 0x2c382434U, 0x5fc2a340U,
     523    0x72161dc3U, 0x0cbce225U, 0x8b283c49U, 0x41ff0d95U,
     524    0x7139a801U, 0xde080cb3U, 0x9cd8b4e4U, 0x906456c1U,
     525    0x617bcb84U, 0x70d532b6U, 0x74486c5cU, 0x42d0b857U,
     526};
     527static const u32 Td2[256] = {
     528    0xa75051f4U, 0x65537e41U, 0xa4c31a17U, 0x5e963a27U,
     529    0x6bcb3babU, 0x45f11f9dU, 0x58abacfaU, 0x03934be3U,
     530    0xfa552030U, 0x6df6ad76U, 0x769188ccU, 0x4c25f502U,
     531    0xd7fc4fe5U, 0xcbd7c52aU, 0x44802635U, 0xa38fb562U,
     532    0x5a49deb1U, 0x1b6725baU, 0x0e9845eaU, 0xc0e15dfeU,
     533    0x7502c32fU, 0xf012814cU, 0x97a38d46U, 0xf9c66bd3U,
     534    0x5fe7038fU, 0x9c951592U, 0x7aebbf6dU, 0x59da9552U,
     535    0x832dd4beU, 0x21d35874U, 0x692949e0U, 0xc8448ec9U,
     536    0x896a75c2U, 0x7978f48eU, 0x3e6b9958U, 0x71dd27b9U,
     537    0x4fb6bee1U, 0xad17f088U, 0xac66c920U, 0x3ab47dceU,
     538    0x4a1863dfU, 0x3182e51aU, 0x33609751U, 0x7f456253U,
     539    0x77e0b164U, 0xae84bb6bU, 0xa01cfe81U, 0x2b94f908U,
     540    0x68587048U, 0xfd198f45U, 0x6c8794deU, 0xf8b7527bU,
     541    0xd323ab73U, 0x02e2724bU, 0x8f57e31fU, 0xab2a6655U,
     542    0x2807b2ebU, 0xc2032fb5U, 0x7b9a86c5U, 0x08a5d337U,
     543    0x87f23028U, 0xa5b223bfU, 0x6aba0203U, 0x825ced16U,
     544    0x1c2b8acfU, 0xb492a779U, 0xf2f0f307U, 0xe2a14e69U,
     545    0xf4cd65daU, 0xbed50605U, 0x621fd134U, 0xfe8ac4a6U,
     546    0x539d342eU, 0x55a0a2f3U, 0xe132058aU, 0xeb75a4f6U,
     547    0xec390b83U, 0xefaa4060U, 0x9f065e71U, 0x1051bd6eU,
     548
     549    0x8af93e21U, 0x063d96ddU, 0x05aedd3eU, 0xbd464de6U,
     550    0x8db59154U, 0x5d0571c4U, 0xd46f0406U, 0x15ff6050U,
     551    0xfb241998U, 0xe997d6bdU, 0x43cc8940U, 0x9e7767d9U,
     552    0x42bdb0e8U, 0x8b880789U, 0x5b38e719U, 0xeedb79c8U,
     553    0x0a47a17cU, 0x0fe97c42U, 0x1ec9f884U, 0x00000000U,
     554    0x86830980U, 0xed48322bU, 0x70ac1e11U, 0x724e6c5aU,
     555    0xfffbfd0eU, 0x38560f85U, 0xd51e3daeU, 0x3927362dU,
     556    0xd9640a0fU, 0xa621685cU, 0x54d19b5bU, 0x2e3a2436U,
     557    0x67b10c0aU, 0xe70f9357U, 0x96d2b4eeU, 0x919e1b9bU,
     558    0xc54f80c0U, 0x20a261dcU, 0x4b695a77U, 0x1a161c12U,
     559    0xba0ae293U, 0x2ae5c0a0U, 0xe0433c22U, 0x171d121bU,
     560    0x0d0b0e09U, 0xc7adf28bU, 0xa8b92db6U, 0xa9c8141eU,
     561    0x198557f1U, 0x074caf75U, 0xddbbee99U, 0x60fda37fU,
     562    0x269ff701U, 0xf5bc5c72U, 0x3bc54466U, 0x7e345bfbU,
     563    0x29768b43U, 0xc6dccb23U, 0xfc68b6edU, 0xf163b8e4U,
     564    0xdccad731U, 0x85104263U, 0x22401397U, 0x112084c6U,
     565    0x247d854aU, 0x3df8d2bbU, 0x3211aef9U, 0xa16dc729U,
     566    0x2f4b1d9eU, 0x30f3dcb2U, 0x52ec0d86U, 0xe3d077c1U,
     567    0x166c2bb3U, 0xb999a970U, 0x48fa1194U, 0x642247e9U,
     568    0x8cc4a8fcU, 0x3f1aa0f0U, 0x2cd8567dU, 0x90ef2233U,
     569    0x4ec78749U, 0xd1c1d938U, 0xa2fe8ccaU, 0x0b3698d4U,
     570    0x81cfa6f5U, 0xde28a57aU, 0x8e26dab7U, 0xbfa43fadU,
     571    0x9de42c3aU, 0x920d5078U, 0xcc9b6a5fU, 0x4662547eU,
     572    0x13c2f68dU, 0xb8e890d8U, 0xf75e2e39U, 0xaff582c3U,
     573    0x80be9f5dU, 0x937c69d0U, 0x2da96fd5U, 0x12b3cf25U,
     574    0x993bc8acU, 0x7da71018U, 0x636ee89cU, 0xbb7bdb3bU,
     575    0x7809cd26U, 0x18f46e59U, 0xb701ec9aU, 0x9aa8834fU,
     576    0x6e65e695U, 0xe67eaaffU, 0xcf0821bcU, 0xe8e6ef15U,
     577    0x9bd9bae7U, 0x36ce4a6fU, 0x09d4ea9fU, 0x7cd629b0U,
     578    0xb2af31a4U, 0x23312a3fU, 0x9430c6a5U, 0x66c035a2U,
     579    0xbc37744eU, 0xcaa6fc82U, 0xd0b0e090U, 0xd81533a7U,
     580    0x984af104U, 0xdaf741ecU, 0x500e7fcdU, 0xf62f1791U,
     581    0xd68d764dU, 0xb04d43efU, 0x4d54ccaaU, 0x04dfe496U,
     582    0xb5e39ed1U, 0x881b4c6aU, 0x1fb8c12cU, 0x517f4665U,
     583    0xea049d5eU, 0x355d018cU, 0x7473fa87U, 0x412efb0bU,
     584    0x1d5ab367U, 0xd25292dbU, 0x5633e910U, 0x47136dd6U,
     585    0x618c9ad7U, 0x0c7a37a1U, 0x148e59f8U, 0x3c89eb13U,
     586    0x27eecea9U, 0xc935b761U, 0xe5ede11cU, 0xb13c7a47U,
     587    0xdf599cd2U, 0x733f55f2U, 0xce791814U, 0x37bf73c7U,
     588    0xcdea53f7U, 0xaa5b5ffdU, 0x6f14df3dU, 0xdb867844U,
     589    0xf381caafU, 0xc43eb968U, 0x342c3824U, 0x405fc2a3U,
     590    0xc372161dU, 0x250cbce2U, 0x498b283cU, 0x9541ff0dU,
     591    0x017139a8U, 0xb3de080cU, 0xe49cd8b4U, 0xc1906456U,
     592    0x84617bcbU, 0xb670d532U, 0x5c74486cU, 0x5742d0b8U,
     593};
     594static const u32 Td3[256] = {
     595    0xf4a75051U, 0x4165537eU, 0x17a4c31aU, 0x275e963aU,
     596    0xab6bcb3bU, 0x9d45f11fU, 0xfa58abacU, 0xe303934bU,
     597    0x30fa5520U, 0x766df6adU, 0xcc769188U, 0x024c25f5U,
     598    0xe5d7fc4fU, 0x2acbd7c5U, 0x35448026U, 0x62a38fb5U,
     599    0xb15a49deU, 0xba1b6725U, 0xea0e9845U, 0xfec0e15dU,
     600    0x2f7502c3U, 0x4cf01281U, 0x4697a38dU, 0xd3f9c66bU,
     601    0x8f5fe703U, 0x929c9515U, 0x6d7aebbfU, 0x5259da95U,
     602    0xbe832dd4U, 0x7421d358U, 0xe0692949U, 0xc9c8448eU,
     603    0xc2896a75U, 0x8e7978f4U, 0x583e6b99U, 0xb971dd27U,
     604    0xe14fb6beU, 0x88ad17f0U, 0x20ac66c9U, 0xce3ab47dU,
     605    0xdf4a1863U, 0x1a3182e5U, 0x51336097U, 0x537f4562U,
     606    0x6477e0b1U, 0x6bae84bbU, 0x81a01cfeU, 0x082b94f9U,
     607    0x48685870U, 0x45fd198fU, 0xde6c8794U, 0x7bf8b752U,
     608    0x73d323abU, 0x4b02e272U, 0x1f8f57e3U, 0x55ab2a66U,
     609    0xeb2807b2U, 0xb5c2032fU, 0xc57b9a86U, 0x3708a5d3U,
     610    0x2887f230U, 0xbfa5b223U, 0x036aba02U, 0x16825cedU,
     611    0xcf1c2b8aU, 0x79b492a7U, 0x07f2f0f3U, 0x69e2a14eU,
     612    0xdaf4cd65U, 0x05bed506U, 0x34621fd1U, 0xa6fe8ac4U,
     613    0x2e539d34U, 0xf355a0a2U, 0x8ae13205U, 0xf6eb75a4U,
     614    0x83ec390bU, 0x60efaa40U, 0x719f065eU, 0x6e1051bdU,
     615    0x218af93eU, 0xdd063d96U, 0x3e05aeddU, 0xe6bd464dU,
     616    0x548db591U, 0xc45d0571U, 0x06d46f04U, 0x5015ff60U,
     617    0x98fb2419U, 0xbde997d6U, 0x4043cc89U, 0xd99e7767U,
     618    0xe842bdb0U, 0x898b8807U, 0x195b38e7U, 0xc8eedb79U,
     619    0x7c0a47a1U, 0x420fe97cU, 0x841ec9f8U, 0x00000000U,
     620    0x80868309U, 0x2bed4832U, 0x1170ac1eU, 0x5a724e6cU,
     621    0x0efffbfdU, 0x8538560fU, 0xaed51e3dU, 0x2d392736U,
     622    0x0fd9640aU, 0x5ca62168U, 0x5b54d19bU, 0x362e3a24U,
     623    0x0a67b10cU, 0x57e70f93U, 0xee96d2b4U, 0x9b919e1bU,
     624    0xc0c54f80U, 0xdc20a261U, 0x774b695aU, 0x121a161cU,
     625    0x93ba0ae2U, 0xa02ae5c0U, 0x22e0433cU, 0x1b171d12U,
     626    0x090d0b0eU, 0x8bc7adf2U, 0xb6a8b92dU, 0x1ea9c814U,
     627    0xf1198557U, 0x75074cafU, 0x99ddbbeeU, 0x7f60fda3U,
     628    0x01269ff7U, 0x72f5bc5cU, 0x663bc544U, 0xfb7e345bU,
     629    0x4329768bU, 0x23c6dccbU, 0xedfc68b6U, 0xe4f163b8U,
     630    0x31dccad7U, 0x63851042U, 0x97224013U, 0xc6112084U,
     631    0x4a247d85U, 0xbb3df8d2U, 0xf93211aeU, 0x29a16dc7U,
     632    0x9e2f4b1dU, 0xb230f3dcU, 0x8652ec0dU, 0xc1e3d077U,
     633    0xb3166c2bU, 0x70b999a9U, 0x9448fa11U, 0xe9642247U,
     634    0xfc8cc4a8U, 0xf03f1aa0U, 0x7d2cd856U, 0x3390ef22U,
     635    0x494ec787U, 0x38d1c1d9U, 0xcaa2fe8cU, 0xd40b3698U,
     636    0xf581cfa6U, 0x7ade28a5U, 0xb78e26daU, 0xadbfa43fU,
     637    0x3a9de42cU, 0x78920d50U, 0x5fcc9b6aU, 0x7e466254U,
     638    0x8d13c2f6U, 0xd8b8e890U, 0x39f75e2eU, 0xc3aff582U,
     639    0x5d80be9fU, 0xd0937c69U, 0xd52da96fU, 0x2512b3cfU,
     640    0xac993bc8U, 0x187da710U, 0x9c636ee8U, 0x3bbb7bdbU,
     641    0x267809cdU, 0x5918f46eU, 0x9ab701ecU, 0x4f9aa883U,
     642    0x956e65e6U, 0xffe67eaaU, 0xbccf0821U, 0x15e8e6efU,
     643    0xe79bd9baU, 0x6f36ce4aU, 0x9f09d4eaU, 0xb07cd629U,
     644    0xa4b2af31U, 0x3f23312aU, 0xa59430c6U, 0xa266c035U,
     645    0x4ebc3774U, 0x82caa6fcU, 0x90d0b0e0U, 0xa7d81533U,
     646    0x04984af1U, 0xecdaf741U, 0xcd500e7fU, 0x91f62f17U,
     647    0x4dd68d76U, 0xefb04d43U, 0xaa4d54ccU, 0x9604dfe4U,
     648    0xd1b5e39eU, 0x6a881b4cU, 0x2c1fb8c1U, 0x65517f46U,
     649    0x5eea049dU, 0x8c355d01U, 0x877473faU, 0x0b412efbU,
     650    0x671d5ab3U, 0xdbd25292U, 0x105633e9U, 0xd647136dU,
     651    0xd7618c9aU, 0xa10c7a37U, 0xf8148e59U, 0x133c89ebU,
     652    0xa927eeceU, 0x61c935b7U, 0x1ce5ede1U, 0x47b13c7aU,
     653    0xd2df599cU, 0xf2733f55U, 0x14ce7918U, 0xc737bf73U,
     654    0xf7cdea53U, 0xfdaa5b5fU, 0x3d6f14dfU, 0x44db8678U,
     655    0xaff381caU, 0x68c43eb9U, 0x24342c38U, 0xa3405fc2U,
     656    0x1dc37216U, 0xe2250cbcU, 0x3c498b28U, 0x0d9541ffU,
     657    0xa8017139U, 0x0cb3de08U, 0xb4e49cd8U, 0x56c19064U,
     658    0xcb84617bU, 0x32b670d5U, 0x6c5c7448U, 0xb85742d0U,
     659};
     660static const u32 Td4[256] = {
     661    0x52525252U, 0x09090909U, 0x6a6a6a6aU, 0xd5d5d5d5U,
     662    0x30303030U, 0x36363636U, 0xa5a5a5a5U, 0x38383838U,
     663    0xbfbfbfbfU, 0x40404040U, 0xa3a3a3a3U, 0x9e9e9e9eU,
     664    0x81818181U, 0xf3f3f3f3U, 0xd7d7d7d7U, 0xfbfbfbfbU,
     665    0x7c7c7c7cU, 0xe3e3e3e3U, 0x39393939U, 0x82828282U,
     666    0x9b9b9b9bU, 0x2f2f2f2fU, 0xffffffffU, 0x87878787U,
     667    0x34343434U, 0x8e8e8e8eU, 0x43434343U, 0x44444444U,
     668    0xc4c4c4c4U, 0xdedededeU, 0xe9e9e9e9U, 0xcbcbcbcbU,
     669    0x54545454U, 0x7b7b7b7bU, 0x94949494U, 0x32323232U,
     670    0xa6a6a6a6U, 0xc2c2c2c2U, 0x23232323U, 0x3d3d3d3dU,
     671    0xeeeeeeeeU, 0x4c4c4c4cU, 0x95959595U, 0x0b0b0b0bU,
     672    0x42424242U, 0xfafafafaU, 0xc3c3c3c3U, 0x4e4e4e4eU,
     673    0x08080808U, 0x2e2e2e2eU, 0xa1a1a1a1U, 0x66666666U,
     674    0x28282828U, 0xd9d9d9d9U, 0x24242424U, 0xb2b2b2b2U,
     675    0x76767676U, 0x5b5b5b5bU, 0xa2a2a2a2U, 0x49494949U,
     676    0x6d6d6d6dU, 0x8b8b8b8bU, 0xd1d1d1d1U, 0x25252525U,
     677    0x72727272U, 0xf8f8f8f8U, 0xf6f6f6f6U, 0x64646464U,
     678    0x86868686U, 0x68686868U, 0x98989898U, 0x16161616U,
     679    0xd4d4d4d4U, 0xa4a4a4a4U, 0x5c5c5c5cU, 0xccccccccU,
     680    0x5d5d5d5dU, 0x65656565U, 0xb6b6b6b6U, 0x92929292U,
     681    0x6c6c6c6cU, 0x70707070U, 0x48484848U, 0x50505050U,
     682    0xfdfdfdfdU, 0xededededU, 0xb9b9b9b9U, 0xdadadadaU,
     683    0x5e5e5e5eU, 0x15151515U, 0x46464646U, 0x57575757U,
     684    0xa7a7a7a7U, 0x8d8d8d8dU, 0x9d9d9d9dU, 0x84848484U,
     685    0x90909090U, 0xd8d8d8d8U, 0xababababU, 0x00000000U,
     686    0x8c8c8c8cU, 0xbcbcbcbcU, 0xd3d3d3d3U, 0x0a0a0a0aU,
     687    0xf7f7f7f7U, 0xe4e4e4e4U, 0x58585858U, 0x05050505U,
     688    0xb8b8b8b8U, 0xb3b3b3b3U, 0x45454545U, 0x06060606U,
     689    0xd0d0d0d0U, 0x2c2c2c2cU, 0x1e1e1e1eU, 0x8f8f8f8fU,
     690    0xcacacacaU, 0x3f3f3f3fU, 0x0f0f0f0fU, 0x02020202U,
     691    0xc1c1c1c1U, 0xafafafafU, 0xbdbdbdbdU, 0x03030303U,
     692    0x01010101U, 0x13131313U, 0x8a8a8a8aU, 0x6b6b6b6bU,
     693    0x3a3a3a3aU, 0x91919191U, 0x11111111U, 0x41414141U,
     694    0x4f4f4f4fU, 0x67676767U, 0xdcdcdcdcU, 0xeaeaeaeaU,
     695    0x97979797U, 0xf2f2f2f2U, 0xcfcfcfcfU, 0xcecececeU,
     696    0xf0f0f0f0U, 0xb4b4b4b4U, 0xe6e6e6e6U, 0x73737373U,
     697    0x96969696U, 0xacacacacU, 0x74747474U, 0x22222222U,
     698    0xe7e7e7e7U, 0xadadadadU, 0x35353535U, 0x85858585U,
     699    0xe2e2e2e2U, 0xf9f9f9f9U, 0x37373737U, 0xe8e8e8e8U,
     700    0x1c1c1c1cU, 0x75757575U, 0xdfdfdfdfU, 0x6e6e6e6eU,
     701    0x47474747U, 0xf1f1f1f1U, 0x1a1a1a1aU, 0x71717171U,
     702    0x1d1d1d1dU, 0x29292929U, 0xc5c5c5c5U, 0x89898989U,
     703    0x6f6f6f6fU, 0xb7b7b7b7U, 0x62626262U, 0x0e0e0e0eU,
     704    0xaaaaaaaaU, 0x18181818U, 0xbebebebeU, 0x1b1b1b1bU,
     705    0xfcfcfcfcU, 0x56565656U, 0x3e3e3e3eU, 0x4b4b4b4bU,
     706    0xc6c6c6c6U, 0xd2d2d2d2U, 0x79797979U, 0x20202020U,
     707    0x9a9a9a9aU, 0xdbdbdbdbU, 0xc0c0c0c0U, 0xfefefefeU,
     708    0x78787878U, 0xcdcdcdcdU, 0x5a5a5a5aU, 0xf4f4f4f4U,
     709    0x1f1f1f1fU, 0xddddddddU, 0xa8a8a8a8U, 0x33333333U,
     710    0x88888888U, 0x07070707U, 0xc7c7c7c7U, 0x31313131U,
     711    0xb1b1b1b1U, 0x12121212U, 0x10101010U, 0x59595959U,
     712    0x27272727U, 0x80808080U, 0xececececU, 0x5f5f5f5fU,
     713    0x60606060U, 0x51515151U, 0x7f7f7f7fU, 0xa9a9a9a9U,
     714    0x19191919U, 0xb5b5b5b5U, 0x4a4a4a4aU, 0x0d0d0d0dU,
     715    0x2d2d2d2dU, 0xe5e5e5e5U, 0x7a7a7a7aU, 0x9f9f9f9fU,
     716    0x93939393U, 0xc9c9c9c9U, 0x9c9c9c9cU, 0xefefefefU,
     717    0xa0a0a0a0U, 0xe0e0e0e0U, 0x3b3b3b3bU, 0x4d4d4d4dU,
     718    0xaeaeaeaeU, 0x2a2a2a2aU, 0xf5f5f5f5U, 0xb0b0b0b0U,
     719    0xc8c8c8c8U, 0xebebebebU, 0xbbbbbbbbU, 0x3c3c3c3cU,
     720    0x83838383U, 0x53535353U, 0x99999999U, 0x61616161U,
     721    0x17171717U, 0x2b2b2b2bU, 0x04040404U, 0x7e7e7e7eU,
     722    0xbabababaU, 0x77777777U, 0xd6d6d6d6U, 0x26262626U,
     723    0xe1e1e1e1U, 0x69696969U, 0x14141414U, 0x63636363U,
     724    0x55555555U, 0x21212121U, 0x0c0c0c0cU, 0x7d7d7d7dU,
     725};
     726static const u32 rcon[] = {
     727        0x01000000, 0x02000000, 0x04000000, 0x08000000,
     728        0x10000000, 0x20000000, 0x40000000, 0x80000000,
     729        0x1B000000, 0x36000000, /* for 128-bit blocks, Rijndael never uses more than 10 rcon values */
     730};
     731
     732
     733#ifdef _MSC_VER
     734#define SWAP(x) (_lrotl(x, 8) & 0x00ff00ff | _lrotr(x, 8) & 0xff00ff00)
     735#define GETU32(p) SWAP(*((u32 *)(p)))
     736#define PUTU32(ct, st) { *((u32 *)(ct)) = SWAP((st)); }
     737#else
     738#define GETU32(pt) (((u32)(pt)[0] << 24) ^ ((u32)(pt)[1] << 16) ^ ((u32)(pt)[2] <<  8) ^ ((u32)(pt)[3]))
     739#define PUTU32(ct, st) { (ct)[0] = (u8)((st) >> 24); (ct)[1] = (u8)((st) >> 16); (ct)[2] = (u8)((st) >>  8); (ct)[3] = (u8)(st); }
     740#endif
     741
     742/**
     743 * Expand the cipher key into the encryption key schedule.
    3744 *
    4  * Optimised ANSI C code
    5  *
    6  * authors: v1.0: Antoon Bosselaers
    7  *          v2.0: Vincent Rijmen
    8  *          v2.3: Paulo Barreto
    9  *
    10  * This code is placed in the public domain.
     745 * @return      the number of rounds for the given cipher key size.
    11746 */
    12 
    13 #include "config_xor.h"
    14 
    15 #include <stdio.h>
    16 #include <stdlib.h>
    17 #include <string.h>
    18 
    19 #ifdef SH_ENCRYPT
    20 
    21 #include "rijndael-alg-fst.h"
    22 
    23 #include "rijndael-boxes-fst.h"
    24 
    25 #if defined(GCC_VERSION_MAJOR)
    26 #if (GCC_VERSION_MAJOR > 4) || ((GCC_VERSION_MAJOR == 4) && (GCC_VERSION_MINOR > 4))
    27 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
    28 #endif
    29 #endif
    30 
    31 int rijndaelKeySched(word8 k[MAXKC][4], word8 W[MAXROUNDS+1][4][4], int ROUNDS) {
    32         /* Calculate the necessary round keys
    33          * The number of calculations depends on keyBits and blockBits
    34          */
    35         int j, r, t, rconpointer = 0;
    36         word8 tk[MAXKC][4] = { { 0 } }; /* init for llvm/clang analyzer */
    37         int KC = ROUNDS - 6;
    38         word32 tmp;
    39 
    40         for (j = KC-1; j >= 0; j--) {
    41           memmove( &(tk[j]), &(k[j]), sizeof(word32));
    42         }
    43         r = 0;
    44         t = 0;
    45 
    46         /* copy values into round key array */
    47         for (j = 0; (j < KC) && (r < ROUNDS + 1); ) {
    48                 for (; (j < KC) && (t < 4); j++, t++) {
    49                   memmove( &(W[r][t]), &(tk[j]), sizeof(word32));
    50                 }
    51                 if (t == 4) {
    52                         r++;
    53                         t = 0;
     747int rijndaelKeySetupEnc(u32 rk[/*4*(Nr + 1)*/], const u8 cipherKey[], int keyBits) {
     748        int i = 0;
     749        u32 temp;
     750
     751        rk[0] = GETU32(cipherKey     );
     752        rk[1] = GETU32(cipherKey +  4);
     753        rk[2] = GETU32(cipherKey +  8);
     754        rk[3] = GETU32(cipherKey + 12);
     755        if (keyBits == 128) {
     756                for (;;) {
     757                        temp  = rk[3];
     758                        rk[4] = rk[0] ^
     759                                (Te4[(temp >> 16) & 0xff] & 0xff000000) ^
     760                                (Te4[(temp >>  8) & 0xff] & 0x00ff0000) ^
     761                                (Te4[(temp      ) & 0xff] & 0x0000ff00) ^
     762                                (Te4[(temp >> 24)       ] & 0x000000ff) ^
     763                                rcon[i];
     764                        rk[5] = rk[1] ^ rk[4];
     765                        rk[6] = rk[2] ^ rk[5];
     766                        rk[7] = rk[3] ^ rk[6];
     767                        if (++i == 10) {
     768                                return 10;
     769                        }
     770                        rk += 4;
    54771                }
    55772        }
    56                
    57         while (r < ROUNDS + 1) { /* while not enough round key material calculated */
    58                 /* calculate new values */
    59                 tk[0][0] ^= S[tk[KC-1][1]];
    60                 tk[0][1] ^= S[tk[KC-1][2]];
    61                 tk[0][2] ^= S[tk[KC-1][3]];
    62                 tk[0][3] ^= S[tk[KC-1][0]];
    63                 tk[0][0] ^= rcon[rconpointer++];
    64 
    65                 if (KC != 8) {
    66                         for (j = 1; j < KC; j++) {
    67                           tmp = *((word32*)tk[j-1]);
    68                           *((word32*)tk[j]) ^= tmp;
     773        rk[4] = GETU32(cipherKey + 16);
     774        rk[5] = GETU32(cipherKey + 20);
     775        if (keyBits == 192) {
     776                for (;;) {
     777                        temp = rk[ 5];
     778                        rk[ 6] = rk[ 0] ^
     779                                (Te4[(temp >> 16) & 0xff] & 0xff000000) ^
     780                                (Te4[(temp >>  8) & 0xff] & 0x00ff0000) ^
     781                                (Te4[(temp      ) & 0xff] & 0x0000ff00) ^
     782                                (Te4[(temp >> 24)       ] & 0x000000ff) ^
     783                                rcon[i];
     784                        rk[ 7] = rk[ 1] ^ rk[ 6];
     785                        rk[ 8] = rk[ 2] ^ rk[ 7];
     786                        rk[ 9] = rk[ 3] ^ rk[ 8];
     787                        if (++i == 8) {
     788                                return 12;
    69789                        }
    70                 } else {
    71                         for (j = 1; j < KC/2; j++) {
    72                           tmp = *((word32*)tk[j-1]);
    73                           *((word32*)tk[j]) ^= tmp;
     790                        rk[10] = rk[ 4] ^ rk[ 9];
     791                        rk[11] = rk[ 5] ^ rk[10];
     792                        rk += 6;
     793                }
     794        }
     795        rk[6] = GETU32(cipherKey + 24);
     796        rk[7] = GETU32(cipherKey + 28);
     797        if (keyBits == 256) {
     798        for (;;) {
     799                temp = rk[ 7];
     800                rk[ 8] = rk[ 0] ^
     801                        (Te4[(temp >> 16) & 0xff] & 0xff000000) ^
     802                        (Te4[(temp >>  8) & 0xff] & 0x00ff0000) ^
     803                        (Te4[(temp      ) & 0xff] & 0x0000ff00) ^
     804                        (Te4[(temp >> 24)       ] & 0x000000ff) ^
     805                        rcon[i];
     806                rk[ 9] = rk[ 1] ^ rk[ 8];
     807                rk[10] = rk[ 2] ^ rk[ 9];
     808                rk[11] = rk[ 3] ^ rk[10];
     809                        if (++i == 7) {
     810                                return 14;
    74811                        }
    75                         tk[KC/2][0] ^= S[tk[KC/2 - 1][0]];
    76                         tk[KC/2][1] ^= S[tk[KC/2 - 1][1]];
    77                         tk[KC/2][2] ^= S[tk[KC/2 - 1][2]];
    78                         tk[KC/2][3] ^= S[tk[KC/2 - 1][3]];
    79                         for (j = KC/2 + 1; j < KC; j++) {
    80                                 tmp = *((word32*)tk[j-1]);
    81                                 *((word32*)tk[j]) ^= tmp;
    82                         }
    83                 }
    84                 /* copy values into round key array */
    85                 for (j = 0; (j < KC) && (r < ROUNDS + 1); ) {
    86                         for (; (j < KC) && (t < 4); j++, t++) {
    87                           memmove( &(W[r][t]), &(tk[j]), sizeof(word32));
    88                         }
    89                         if (t == 4) {
    90                                 r++;
    91                                 t = 0;
    92                         }
    93                 }
    94         }               
     812                temp = rk[11];
     813                rk[12] = rk[ 4] ^
     814                        (Te4[(temp >> 24)       ] & 0xff000000) ^
     815                        (Te4[(temp >> 16) & 0xff] & 0x00ff0000) ^
     816                        (Te4[(temp >>  8) & 0xff] & 0x0000ff00) ^
     817                        (Te4[(temp      ) & 0xff] & 0x000000ff);
     818                rk[13] = rk[ 5] ^ rk[12];
     819                rk[14] = rk[ 6] ^ rk[13];
     820                rk[15] = rk[ 7] ^ rk[14];
     821
     822                        rk += 8;
     823        }
     824        }
    95825        return 0;
    96826}
    97827
    98 int rijndaelKeyEncToDec(word8 W[MAXROUNDS+1][4][4], int ROUNDS) {
    99         int r;
    100         word8 *w;
    101 
    102         for (r = 1; r < ROUNDS; r++) {
    103                 w = W[r][0];
    104                 *((word32*)w) =
    105                           *((word32*)U1[w[0]])
    106                         ^ *((word32*)U2[w[1]])
    107                         ^ *((word32*)U3[w[2]])
    108                         ^ *((word32*)U4[w[3]]);
    109 
    110                 w = W[r][1];
    111                 *((word32*)w) =
    112                           *((word32*)U1[w[0]])
    113                         ^ *((word32*)U2[w[1]])
    114                         ^ *((word32*)U3[w[2]])
    115                         ^ *((word32*)U4[w[3]]);
    116 
    117                 w = W[r][2];
    118                 *((word32*)w) =
    119                           *((word32*)U1[w[0]])
    120                         ^ *((word32*)U2[w[1]])
    121                         ^ *((word32*)U3[w[2]])
    122                         ^ *((word32*)U4[w[3]]);
    123 
    124                 w = W[r][3];
    125                 *((word32*)w) =
    126                           *((word32*)U1[w[0]])
    127                         ^ *((word32*)U2[w[1]])
    128                         ^ *((word32*)U3[w[2]])
    129                         ^ *((word32*)U4[w[3]]);
     828/**
     829 * Expand the cipher key into the decryption key schedule.
     830 *
     831 * @return      the number of rounds for the given cipher key size.
     832 */
     833int rijndaelKeySetupDec(u32 rk[/*4*(Nr + 1)*/], const u8 cipherKey[], int keyBits) {
     834        int Nr, i, j;
     835        u32 temp;
     836
     837        /* expand the cipher key: */
     838        Nr = rijndaelKeySetupEnc(rk, cipherKey, keyBits);
     839        /* invert the order of the round keys: */
     840        for (i = 0, j = 4*Nr; i < j; i += 4, j -= 4) {
     841                temp = rk[i    ]; rk[i    ] = rk[j    ]; rk[j    ] = temp;
     842                temp = rk[i + 1]; rk[i + 1] = rk[j + 1]; rk[j + 1] = temp;
     843                temp = rk[i + 2]; rk[i + 2] = rk[j + 2]; rk[j + 2] = temp;
     844                temp = rk[i + 3]; rk[i + 3] = rk[j + 3]; rk[j + 3] = temp;
    130845        }
    131         return 0;
    132 }       
    133 
    134 /**
    135  * Encrypt a single block.
    136  */
    137 int rijndaelEncrypt(word8 a[16], word8 b[16], word8 rk[MAXROUNDS+1][4][4], int ROUNDS) {
    138         int r;
    139         union {
    140           word32 tem4[4];
    141           word8  temp[4][4];
    142         } tmpU;
    143         tmpU.tem4[0] = tmpU.tem4[1] = tmpU.tem4[2] = tmpU.tem4[3] = 0;
    144 
    145     tmpU.tem4[0] = *((word32*)(a   )) ^ *((word32*)rk[0][0]);
    146     tmpU.tem4[1] = *((word32*)(a+ 4)) ^ *((word32*)rk[0][1]);
    147     tmpU.tem4[2] = *((word32*)(a+ 8)) ^ *((word32*)rk[0][2]);
    148     tmpU.tem4[3] = *((word32*)(a+12)) ^ *((word32*)rk[0][3]);
    149     *((word32*)(b    )) = *((word32*)T1[tmpU.temp[0][0]])
    150                                                 ^ *((word32*)T2[tmpU.temp[1][1]])
    151                                                 ^ *((word32*)T3[tmpU.temp[2][2]])
    152                                                 ^ *((word32*)T4[tmpU.temp[3][3]]);
    153     *((word32*)(b + 4)) = *((word32*)T1[tmpU.temp[1][0]])
    154                                                 ^ *((word32*)T2[tmpU.temp[2][1]])
    155                                                 ^ *((word32*)T3[tmpU.temp[3][2]])
    156                                                 ^ *((word32*)T4[tmpU.temp[0][3]]);
    157     *((word32*)(b + 8)) = *((word32*)T1[tmpU.temp[2][0]])
    158                                                 ^ *((word32*)T2[tmpU.temp[3][1]])
    159                                                 ^ *((word32*)T3[tmpU.temp[0][2]])
    160                                                 ^ *((word32*)T4[tmpU.temp[1][3]]);
    161     *((word32*)(b +12)) = *((word32*)T1[tmpU.temp[3][0]])
    162                                                 ^ *((word32*)T2[tmpU.temp[0][1]])
    163                                                 ^ *((word32*)T3[tmpU.temp[1][2]])
    164                                                 ^ *((word32*)T4[tmpU.temp[2][3]]);
    165         for (r = 1; r < ROUNDS-1; r++) {
    166                 tmpU.tem4[0] = *((word32*)(b   )) ^ *((word32*)rk[r][0]);
    167                 tmpU.tem4[1] = *((word32*)(b+ 4)) ^ *((word32*)rk[r][1]);
    168                 tmpU.tem4[2] = *((word32*)(b+ 8)) ^ *((word32*)rk[r][2]);
    169                 tmpU.tem4[3] = *((word32*)(b+12)) ^ *((word32*)rk[r][3]);
    170 
    171                 *((word32*)(b    )) = *((word32*)T1[tmpU.temp[0][0]])
    172                                                         ^ *((word32*)T2[tmpU.temp[1][1]])
    173                                                         ^ *((word32*)T3[tmpU.temp[2][2]])
    174                                                         ^ *((word32*)T4[tmpU.temp[3][3]]);
    175                 *((word32*)(b + 4)) = *((word32*)T1[tmpU.temp[1][0]])
    176                                                         ^ *((word32*)T2[tmpU.temp[2][1]])
    177                                                         ^ *((word32*)T3[tmpU.temp[3][2]])
    178                                                         ^ *((word32*)T4[tmpU.temp[0][3]]);
    179                 *((word32*)(b + 8)) = *((word32*)T1[tmpU.temp[2][0]])
    180                                                         ^ *((word32*)T2[tmpU.temp[3][1]])
    181                                                         ^ *((word32*)T3[tmpU.temp[0][2]])
    182                                                         ^ *((word32*)T4[tmpU.temp[1][3]]);
    183                 *((word32*)(b +12)) = *((word32*)T1[tmpU.temp[3][0]])
    184                                                         ^ *((word32*)T2[tmpU.temp[0][1]])
    185                                                         ^ *((word32*)T3[tmpU.temp[1][2]])
    186                                                         ^ *((word32*)T4[tmpU.temp[2][3]]);
     846        /* apply the inverse MixColumn transform to all round keys but the first and the last: */
     847        for (i = 1; i < Nr; i++) {
     848                rk += 4;
     849                rk[0] =
     850                        Td0[Te4[(rk[0] >> 24)       ] & 0xff] ^
     851                        Td1[Te4[(rk[0] >> 16) & 0xff] & 0xff] ^
     852                        Td2[Te4[(rk[0] >>  8) & 0xff] & 0xff] ^
     853                        Td3[Te4[(rk[0]      ) & 0xff] & 0xff];
     854                rk[1] =
     855                        Td0[Te4[(rk[1] >> 24)       ] & 0xff] ^
     856                        Td1[Te4[(rk[1] >> 16) & 0xff] & 0xff] ^
     857                        Td2[Te4[(rk[1] >>  8) & 0xff] & 0xff] ^
     858                        Td3[Te4[(rk[1]      ) & 0xff] & 0xff];
     859                rk[2] =
     860                        Td0[Te4[(rk[2] >> 24)       ] & 0xff] ^
     861                        Td1[Te4[(rk[2] >> 16) & 0xff] & 0xff] ^
     862                        Td2[Te4[(rk[2] >>  8) & 0xff] & 0xff] ^
     863                        Td3[Te4[(rk[2]      ) & 0xff] & 0xff];
     864                rk[3] =
     865                        Td0[Te4[(rk[3] >> 24)       ] & 0xff] ^
     866                        Td1[Te4[(rk[3] >> 16) & 0xff] & 0xff] ^
     867                        Td2[Te4[(rk[3] >>  8) & 0xff] & 0xff] ^
     868                        Td3[Te4[(rk[3]      ) & 0xff] & 0xff];
    187869        }
    188         /* last round is special */   
    189         tmpU.tem4[0] = *((word32*)(b   )) ^ *((word32*)rk[ROUNDS-1][0]);
    190         tmpU.tem4[1] = *((word32*)(b+ 4)) ^ *((word32*)rk[ROUNDS-1][1]);
    191         tmpU.tem4[2] = *((word32*)(b+ 8)) ^ *((word32*)rk[ROUNDS-1][2]);
    192         tmpU.tem4[3] = *((word32*)(b+12)) ^ *((word32*)rk[ROUNDS-1][3]);
    193         b[ 0] = T1[tmpU.temp[0][0]][1];
    194         b[ 1] = T1[tmpU.temp[1][1]][1];
    195         b[ 2] = T1[tmpU.temp[2][2]][1];
    196         b[ 3] = T1[tmpU.temp[3][3]][1];
    197         b[ 4] = T1[tmpU.temp[1][0]][1];
    198         b[ 5] = T1[tmpU.temp[2][1]][1];
    199         b[ 6] = T1[tmpU.temp[3][2]][1];
    200         b[ 7] = T1[tmpU.temp[0][3]][1];
    201         b[ 8] = T1[tmpU.temp[2][0]][1];
    202         b[ 9] = T1[tmpU.temp[3][1]][1];
    203         b[10] = T1[tmpU.temp[0][2]][1];
    204         b[11] = T1[tmpU.temp[1][3]][1];
    205         b[12] = T1[tmpU.temp[3][0]][1];
    206         b[13] = T1[tmpU.temp[0][1]][1];
    207         b[14] = T1[tmpU.temp[1][2]][1];
    208         b[15] = T1[tmpU.temp[2][3]][1];
    209         *((word32*)(b   )) ^= *((word32*)rk[ROUNDS][0]);
    210         *((word32*)(b+ 4)) ^= *((word32*)rk[ROUNDS][1]);
    211         *((word32*)(b+ 8)) ^= *((word32*)rk[ROUNDS][2]);
    212         *((word32*)(b+12)) ^= *((word32*)rk[ROUNDS][3]);
    213 
    214         return 0;
     870        return Nr;
    215871}
    216872
    217 /**
    218  * Decrypt a single block.
    219  */
    220 int rijndaelDecrypt(word8 a[16], word8 b[16], word8 rk[MAXROUNDS+1][4][4], int ROUNDS) {
    221         int r;
    222         union {
    223           word32 tem4[4];
    224           word8  temp[4][4];
    225         } tmpU;
    226         tmpU.tem4[0] = tmpU.tem4[1] = tmpU.tem4[2] = tmpU.tem4[3] = 0;
    227        
    228     tmpU.tem4[0] = *((word32*)(a   )) ^ *((word32*)rk[ROUNDS][0]);
    229     tmpU.tem4[1] = *((word32*)(a+ 4)) ^ *((word32*)rk[ROUNDS][1]);
    230     tmpU.tem4[2] = *((word32*)(a+ 8)) ^ *((word32*)rk[ROUNDS][2]);
    231     tmpU.tem4[3] = *((word32*)(a+12)) ^ *((word32*)rk[ROUNDS][3]);
    232 
    233     *((word32*)(b   )) = *((word32*)T5[tmpU.temp[0][0]])
    234            ^ *((word32*)T6[tmpU.temp[3][1]])
    235            ^ *((word32*)T7[tmpU.temp[2][2]])
    236            ^ *((word32*)T8[tmpU.temp[1][3]]);
    237         *((word32*)(b+ 4)) = *((word32*)T5[tmpU.temp[1][0]])
    238            ^ *((word32*)T6[tmpU.temp[0][1]])
    239            ^ *((word32*)T7[tmpU.temp[3][2]])
    240            ^ *((word32*)T8[tmpU.temp[2][3]]);
    241         *((word32*)(b+ 8)) = *((word32*)T5[tmpU.temp[2][0]])
    242            ^ *((word32*)T6[tmpU.temp[1][1]])
    243            ^ *((word32*)T7[tmpU.temp[0][2]])
    244            ^ *((word32*)T8[tmpU.temp[3][3]]);
    245         *((word32*)(b+12)) = *((word32*)T5[tmpU.temp[3][0]])
    246            ^ *((word32*)T6[tmpU.temp[2][1]])
    247            ^ *((word32*)T7[tmpU.temp[1][2]])
    248            ^ *((word32*)T8[tmpU.temp[0][3]]);
    249         for (r = ROUNDS-1; r > 1; r--) {
    250                 tmpU.tem4[0] = *((word32*)(b   )) ^ *((word32*)rk[r][0]);
    251                 tmpU.tem4[1] = *((word32*)(b+ 4)) ^ *((word32*)rk[r][1]);
    252                 tmpU.tem4[2] = *((word32*)(b+ 8)) ^ *((word32*)rk[r][2]);
    253                 tmpU.tem4[3] = *((word32*)(b+12)) ^ *((word32*)rk[r][3]);
    254                 *((word32*)(b   )) = *((word32*)T5[tmpU.temp[0][0]])
    255            ^ *((word32*)T6[tmpU.temp[3][1]])
    256            ^ *((word32*)T7[tmpU.temp[2][2]])
    257            ^ *((word32*)T8[tmpU.temp[1][3]]);
    258                 *((word32*)(b+ 4)) = *((word32*)T5[tmpU.temp[1][0]])
    259            ^ *((word32*)T6[tmpU.temp[0][1]])
    260            ^ *((word32*)T7[tmpU.temp[3][2]])
    261            ^ *((word32*)T8[tmpU.temp[2][3]]);
    262                 *((word32*)(b+ 8)) = *((word32*)T5[tmpU.temp[2][0]])
    263            ^ *((word32*)T6[tmpU.temp[1][1]])
    264            ^ *((word32*)T7[tmpU.temp[0][2]])
    265            ^ *((word32*)T8[tmpU.temp[3][3]]);
    266                 *((word32*)(b+12)) = *((word32*)T5[tmpU.temp[3][0]])
    267            ^ *((word32*)T6[tmpU.temp[2][1]])
    268            ^ *((word32*)T7[tmpU.temp[1][2]])
    269            ^ *((word32*)T8[tmpU.temp[0][3]]);
    270         }
    271         /* last round is special */   
    272         tmpU.tem4[0] = *((word32*)(b   )) ^ *((word32*)rk[1][0]);
    273         tmpU.tem4[1] = *((word32*)(b+ 4)) ^ *((word32*)rk[1][1]);
    274         tmpU.tem4[2] = *((word32*)(b+ 8)) ^ *((word32*)rk[1][2]);
    275         tmpU.tem4[3] = *((word32*)(b+12)) ^ *((word32*)rk[1][3]);
    276         b[ 0] = S5[tmpU.temp[0][0]];
    277         b[ 1] = S5[tmpU.temp[3][1]];
    278         b[ 2] = S5[tmpU.temp[2][2]];
    279         b[ 3] = S5[tmpU.temp[1][3]];
    280         b[ 4] = S5[tmpU.temp[1][0]];
    281         b[ 5] = S5[tmpU.temp[0][1]];
    282         b[ 6] = S5[tmpU.temp[3][2]];
    283         b[ 7] = S5[tmpU.temp[2][3]];
    284         b[ 8] = S5[tmpU.temp[2][0]];
    285         b[ 9] = S5[tmpU.temp[1][1]];
    286         b[10] = S5[tmpU.temp[0][2]];
    287         b[11] = S5[tmpU.temp[3][3]];
    288         b[12] = S5[tmpU.temp[3][0]];
    289         b[13] = S5[tmpU.temp[2][1]];
    290         b[14] = S5[tmpU.temp[1][2]];
    291         b[15] = S5[tmpU.temp[0][3]];
    292         *((word32*)(b   )) ^= *((word32*)rk[0][0]);
    293         *((word32*)(b+ 4)) ^= *((word32*)rk[0][1]);
    294         *((word32*)(b+ 8)) ^= *((word32*)rk[0][2]);
    295         *((word32*)(b+12)) ^= *((word32*)rk[0][3]);
    296 
    297         return 0;
     873void rijndaelEncrypt(const u32 rk[/*4*(Nr + 1)*/], int Nr, const u8 pt[16], u8 ct[16]) {
     874        u32 s0, s1, s2, s3, t0, t1, t2, t3;
     875#ifndef FULL_UNROLL
     876    int r;
     877#endif /* ?FULL_UNROLL */
     878
     879    /*
     880         * map byte array block to cipher state
     881         * and add initial round key:
     882         */
     883        s0 = GETU32(pt     ) ^ rk[0];
     884        s1 = GETU32(pt +  4) ^ rk[1];
     885        s2 = GETU32(pt +  8) ^ rk[2];
     886        s3 = GETU32(pt + 12) ^ rk[3];
     887#ifdef FULL_UNROLL
     888    /* round 1: */
     889        t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[ 4];
     890        t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[ 5];
     891        t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[ 6];
     892        t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[ 7];
     893        /* round 2: */
     894        s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>  8) & 0xff] ^ Te3[t3 & 0xff] ^ rk[ 8];
     895        s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>  8) & 0xff] ^ Te3[t0 & 0xff] ^ rk[ 9];
     896        s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>  8) & 0xff] ^ Te3[t1 & 0xff] ^ rk[10];
     897        s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>  8) & 0xff] ^ Te3[t2 & 0xff] ^ rk[11];
     898    /* round 3: */
     899        t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[12];
     900        t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[13];
     901        t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[14];
     902        t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[15];
     903        /* round 4: */
     904        s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>  8) & 0xff] ^ Te3[t3 & 0xff] ^ rk[16];
     905        s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>  8) & 0xff] ^ Te3[t0 & 0xff] ^ rk[17];
     906        s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>  8) & 0xff] ^ Te3[t1 & 0xff] ^ rk[18];
     907        s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>  8) & 0xff] ^ Te3[t2 & 0xff] ^ rk[19];
     908    /* round 5: */
     909        t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[20];
     910        t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[21];
     911        t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[22];
     912        t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[23];
     913        /* round 6: */
     914        s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>  8) & 0xff] ^ Te3[t3 & 0xff] ^ rk[24];
     915        s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>  8) & 0xff] ^ Te3[t0 & 0xff] ^ rk[25];
     916        s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>  8) & 0xff] ^ Te3[t1 & 0xff] ^ rk[26];
     917        s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>  8) & 0xff] ^ Te3[t2 & 0xff] ^ rk[27];
     918    /* round 7: */
     919        t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[28];
     920        t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[29];
     921        t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[30];
     922        t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[31];
     923        /* round 8: */
     924        s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>  8) & 0xff] ^ Te3[t3 & 0xff] ^ rk[32];
     925        s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>  8) & 0xff] ^ Te3[t0 & 0xff] ^ rk[33];
     926        s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>  8) & 0xff] ^ Te3[t1 & 0xff] ^ rk[34];
     927        s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>  8) & 0xff] ^ Te3[t2 & 0xff] ^ rk[35];
     928    /* round 9: */
     929        t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[36];
     930        t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[37];
     931        t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[38];
     932        t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[39];
     933    if (Nr > 10) {
     934        /* round 10: */
     935        s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>  8) & 0xff] ^ Te3[t3 & 0xff] ^ rk[40];
     936        s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>  8) & 0xff] ^ Te3[t0 & 0xff] ^ rk[41];
     937        s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>  8) & 0xff] ^ Te3[t1 & 0xff] ^ rk[42];
     938        s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>  8) & 0xff] ^ Te3[t2 & 0xff] ^ rk[43];
     939        /* round 11: */
     940        t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[44];
     941        t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[45];
     942        t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[46];
     943        t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[47];
     944        if (Nr > 12) {
     945            /* round 12: */
     946            s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>  8) & 0xff] ^ Te3[t3 & 0xff] ^ rk[48];
     947            s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>  8) & 0xff] ^ Te3[t0 & 0xff] ^ rk[49];
     948            s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>  8) & 0xff] ^ Te3[t1 & 0xff] ^ rk[50];
     949            s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>  8) & 0xff] ^ Te3[t2 & 0xff] ^ rk[51];
     950            /* round 13: */
     951            t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[52];
     952            t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[53];
     953            t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[54];
     954            t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[55];
     955        }
     956    }
     957    rk += Nr << 2;
     958#else  /* !FULL_UNROLL */
     959    /*
     960         * Nr - 1 full rounds:
     961         */
     962    r = Nr >> 1;
     963    for (;;) {
     964        t0 =
     965            Te0[(s0 >> 24)       ] ^
     966            Te1[(s1 >> 16) & 0xff] ^
     967            Te2[(s2 >>  8) & 0xff] ^
     968            Te3[(s3      ) & 0xff] ^
     969            rk[4];
     970        t1 =
     971            Te0[(s1 >> 24)       ] ^
     972            Te1[(s2 >> 16) & 0xff] ^
     973            Te2[(s3 >>  8) & 0xff] ^
     974            Te3[(s0      ) & 0xff] ^
     975            rk[5];
     976        t2 =
     977            Te0[(s2 >> 24)       ] ^
     978            Te1[(s3 >> 16) & 0xff] ^
     979            Te2[(s0 >>  8) & 0xff] ^
     980            Te3[(s1      ) & 0xff] ^
     981            rk[6];
     982        t3 =
     983            Te0[(s3 >> 24)       ] ^
     984            Te1[(s0 >> 16) & 0xff] ^
     985            Te2[(s1 >>  8) & 0xff] ^
     986            Te3[(s2      ) & 0xff] ^
     987            rk[7];
     988
     989        rk += 8;
     990        if (--r == 0) {
     991            break;
     992        }
     993
     994        s0 =
     995            Te0[(t0 >> 24)       ] ^
     996            Te1[(t1 >> 16) & 0xff] ^
     997            Te2[(t2 >>  8) & 0xff] ^
     998            Te3[(t3      ) & 0xff] ^
     999            rk[0];
     1000        s1 =
     1001            Te0[(t1 >> 24)       ] ^
     1002            Te1[(t2 >> 16) & 0xff] ^
     1003            Te2[(t3 >>  8) & 0xff] ^
     1004            Te3[(t0      ) & 0xff] ^
     1005            rk[1];
     1006        s2 =
     1007            Te0[(t2 >> 24)       ] ^
     1008            Te1[(t3 >> 16) & 0xff] ^
     1009            Te2[(t0 >>  8) & 0xff] ^
     1010            Te3[(t1      ) & 0xff] ^
     1011            rk[2];
     1012        s3 =
     1013            Te0[(t3 >> 24)       ] ^
     1014            Te1[(t0 >> 16) & 0xff] ^
     1015            Te2[(t1 >>  8) & 0xff] ^
     1016            Te3[(t2      ) & 0xff] ^
     1017            rk[3];
     1018    }
     1019#endif /* ?FULL_UNROLL */
     1020    /*
     1021         * apply last round and
     1022         * map cipher state to byte array block:
     1023         */
     1024        s0 =
     1025                (Te4[(t0 >> 24)       ] & 0xff000000) ^
     1026                (Te4[(t1 >> 16) & 0xff] & 0x00ff0000) ^
     1027                (Te4[(t2 >>  8) & 0xff] & 0x0000ff00) ^
     1028                (Te4[(t3      ) & 0xff] & 0x000000ff) ^
     1029                rk[0];
     1030        PUTU32(ct     , s0);
     1031        s1 =
     1032                (Te4[(t1 >> 24)       ] & 0xff000000) ^
     1033                (Te4[(t2 >> 16) & 0xff] & 0x00ff0000) ^
     1034                (Te4[(t3 >>  8) & 0xff] & 0x0000ff00) ^
     1035                (Te4[(t0      ) & 0xff] & 0x000000ff) ^
     1036                rk[1];
     1037        PUTU32(ct +  4, s1);
     1038        s2 =
     1039                (Te4[(t2 >> 24)       ] & 0xff000000) ^
     1040                (Te4[(t3 >> 16) & 0xff] & 0x00ff0000) ^
     1041                (Te4[(t0 >>  8) & 0xff] & 0x0000ff00) ^
     1042                (Te4[(t1      ) & 0xff] & 0x000000ff) ^
     1043                rk[2];
     1044        PUTU32(ct +  8, s2);
     1045        s3 =
     1046                (Te4[(t3 >> 24)       ] & 0xff000000) ^
     1047                (Te4[(t0 >> 16) & 0xff] & 0x00ff0000) ^
     1048                (Te4[(t1 >>  8) & 0xff] & 0x0000ff00) ^
     1049                (Te4[(t2      ) & 0xff] & 0x000000ff) ^
     1050                rk[3];
     1051        PUTU32(ct + 12, s3);
    2981052}
    2991053
    300 #ifdef INTERMEDIATE_VALUE_KAT
    301 /**
    302  * Encrypt only a certain number of rounds.
    303  * Only used in the Intermediate Value Known Answer Test.
    304  */
    305 int rijndaelEncryptRound(word8 a[4][4], word8 rk[MAXROUNDS+1][4][4], int ROUNDS, int rounds) {
    306         int r;
    307         word8 temp[4][4];
    308 
    309         /* make number of rounds sane */
    310         if (rounds > ROUNDS) {
    311                 rounds = ROUNDS;
    312         }
    313 
    314         *((word32*)a[0]) = *((word32*)a[0]) ^ *((word32*)rk[0][0]);
    315         *((word32*)a[1]) = *((word32*)a[1]) ^ *((word32*)rk[0][1]);
    316         *((word32*)a[2]) = *((word32*)a[2]) ^ *((word32*)rk[0][2]);
    317         *((word32*)a[3]) = *((word32*)a[3]) ^ *((word32*)rk[0][3]);
    318 
    319         for (r = 1; (r <= rounds) && (r < ROUNDS); r++) {
    320                 *((word32*)temp[0]) = *((word32*)T1[a[0][0]])
    321            ^ *((word32*)T2[a[1][1]])
    322            ^ *((word32*)T3[a[2][2]])
    323            ^ *((word32*)T4[a[3][3]]);
    324                 *((word32*)temp[1]) = *((word32*)T1[a[1][0]])
    325            ^ *((word32*)T2[a[2][1]])
    326            ^ *((word32*)T3[a[3][2]])
    327            ^ *((word32*)T4[a[0][3]]);
    328                 *((word32*)temp[2]) = *((word32*)T1[a[2][0]])
    329            ^ *((word32*)T2[a[3][1]])
    330            ^ *((word32*)T3[a[0][2]])
    331            ^ *((word32*)T4[a[1][3]]);
    332                 *((word32*)temp[3]) = *((word32*)T1[a[3][0]])
    333            ^ *((word32*)T2[a[0][1]])
    334            ^ *((word32*)T3[a[1][2]])
    335            ^ *((word32*)T4[a[2][3]]);
    336                 *((word32*)a[0]) = *((word32*)temp[0]) ^ *((word32*)rk[r][0]);
    337                 *((word32*)a[1]) = *((word32*)temp[1]) ^ *((word32*)rk[r][1]);
    338                 *((word32*)a[2]) = *((word32*)temp[2]) ^ *((word32*)rk[r][2]);
    339                 *((word32*)a[3]) = *((word32*)temp[3]) ^ *((word32*)rk[r][3]);
    340         }
    341         if (rounds == ROUNDS) {
    342                 /* last round is special */   
    343                 temp[0][0] = T1[a[0][0]][1];
    344                 temp[0][1] = T1[a[1][1]][1];
    345                 temp[0][2] = T1[a[2][2]][1];
    346                 temp[0][3] = T1[a[3][3]][1];
    347                 temp[1][0] = T1[a[1][0]][1];
    348                 temp[1][1] = T1[a[2][1]][1];
    349                 temp[1][2] = T1[a[3][2]][1];
    350                 temp[1][3] = T1[a[0][3]][1];
    351                 temp[2][0] = T1[a[2][0]][1];
    352                 temp[2][1] = T1[a[3][1]][1];
    353                 temp[2][2] = T1[a[0][2]][1];
    354                 temp[2][3] = T1[a[1][3]][1];
    355                 temp[3][0] = T1[a[3][0]][1];
    356                 temp[3][1] = T1[a[0][1]][1];
    357                 temp[3][2] = T1[a[1][2]][1];
    358                 temp[3][3] = T1[a[2][3]][1];
    359                 *((word32*)a[0]) = *((word32*)temp[0]) ^ *((word32*)rk[ROUNDS][0]);
    360                 *((word32*)a[1]) = *((word32*)temp[1]) ^ *((word32*)rk[ROUNDS][1]);
    361                 *((word32*)a[2]) = *((word32*)temp[2]) ^ *((word32*)rk[ROUNDS][2]);
    362                 *((word32*)a[3]) = *((word32*)temp[3]) ^ *((word32*)rk[ROUNDS][3]);
    363         }
    364 
    365         return 0;
    366 }   
    367 #endif /* INTERMEDIATE_VALUE_KAT */
    368 
    369 #ifdef INTERMEDIATE_VALUE_KAT
    370 /**
    371  * Decrypt only a certain number of rounds.
    372  * Only used in the Intermediate Value Known Answer Test.
    373  * Operations rearranged such that the intermediate values
    374  * of decryption correspond with the intermediate values
    375  * of encryption.
    376  */
    377 int rijndaelDecryptRound(word8 a[4][4], word8 rk[MAXROUNDS+1][4][4], int ROUNDS, int rounds) {
    378         int r, i;
    379         word8 temp[4], shift;
    380 
    381         /* make number of rounds sane */
    382         if (rounds > ROUNDS) {
    383                 rounds = ROUNDS;
    384         }
    385     /* first round is special: */
    386         *(word32 *)a[0] ^= *(word32 *)rk[ROUNDS][0];
    387         *(word32 *)a[1] ^= *(word32 *)rk[ROUNDS][1];
    388         *(word32 *)a[2] ^= *(word32 *)rk[ROUNDS][2];
    389         *(word32 *)a[3] ^= *(word32 *)rk[ROUNDS][3];
    390         for (i = 0; i < 4; i++) {
    391                 a[i][0] = Si[a[i][0]];
    392                 a[i][1] = Si[a[i][1]];
    393                 a[i][2] = Si[a[i][2]];
    394                 a[i][3] = Si[a[i][3]];
    395         }
    396         for (i = 1; i < 4; i++) {
    397                 shift = (4 - i) & 3;
    398                 temp[0] = a[(0 + shift) & 3][i];
    399                 temp[1] = a[(1 + shift) & 3][i];
    400                 temp[2] = a[(2 + shift) & 3][i];
    401                 temp[3] = a[(3 + shift) & 3][i];
    402                 a[0][i] = temp[0];
    403                 a[1][i] = temp[1];
    404                 a[2][i] = temp[2];
    405                 a[3][i] = temp[3];
    406         }
    407         /* ROUNDS-1 ordinary rounds */
    408         for (r = ROUNDS-1; r > rounds; r--) {
    409                 *(word32 *)a[0] ^= *(word32 *)rk[r][0];
    410                 *(word32 *)a[1] ^= *(word32 *)rk[r][1];
    411                 *(word32 *)a[2] ^= *(word32 *)rk[r][2];
    412                 *(word32 *)a[3] ^= *(word32 *)rk[r][3];
    413 
    414                 *((word32*)a[0]) =
    415                           *((word32*)U1[a[0][0]])
    416                         ^ *((word32*)U2[a[0][1]])
    417                         ^ *((word32*)U3[a[0][2]])
    418                         ^ *((word32*)U4[a[0][3]]);
    419 
    420                 *((word32*)a[1]) =
    421                           *((word32*)U1[a[1][0]])
    422                         ^ *((word32*)U2[a[1][1]])
    423                         ^ *((word32*)U3[a[1][2]])
    424                         ^ *((word32*)U4[a[1][3]]);
    425 
    426                 *((word32*)a[2]) =
    427                           *((word32*)U1[a[2][0]])
    428                         ^ *((word32*)U2[a[2][1]])
    429                         ^ *((word32*)U3[a[2][2]])
    430                         ^ *((word32*)U4[a[2][3]]);
    431 
    432                 *((word32*)a[3]) =
    433                           *((word32*)U1[a[3][0]])
    434                         ^ *((word32*)U2[a[3][1]])
    435                         ^ *((word32*)U3[a[3][2]])
    436                         ^ *((word32*)U4[a[3][3]]);
    437                 for (i = 0; i < 4; i++) {
    438                         a[i][0] = Si[a[i][0]];
    439                         a[i][1] = Si[a[i][1]];
    440                         a[i][2] = Si[a[i][2]];
    441                         a[i][3] = Si[a[i][3]];
    442                 }
    443                 for (i = 1; i < 4; i++) {
    444                         shift = (4 - i) & 3;
    445                         temp[0] = a[(0 + shift) & 3][i];
    446                         temp[1] = a[(1 + shift) & 3][i];
    447                         temp[2] = a[(2 + shift) & 3][i];
    448                         temp[3] = a[(3 + shift) & 3][i];
    449                         a[0][i] = temp[0];
    450                         a[1][i] = temp[1];
    451                         a[2][i] = temp[2];
    452                         a[3][i] = temp[3];
    453                 }
    454         }
    455         if (rounds == 0) {
    456                 /* End with the extra key addition */   
    457                 *(word32 *)a[0] ^= *(word32 *)rk[0][0];
    458                 *(word32 *)a[1] ^= *(word32 *)rk[0][1];
    459                 *(word32 *)a[2] ^= *(word32 *)rk[0][2];
    460                 *(word32 *)a[3] ^= *(word32 *)rk[0][3];
    461         }   
    462         return 0;
     1054void rijndaelDecrypt(const u32 rk[/*4*(Nr + 1)*/], int Nr, const u8 ct[16], u8 pt[16]) {
     1055        u32 s0, s1, s2, s3, t0, t1, t2, t3;
     1056#ifndef FULL_UNROLL
     1057    int r;
     1058#endif /* ?FULL_UNROLL */
     1059
     1060    /*
     1061         * map byte array block to cipher state
     1062         * and add initial round key:
     1063         */
     1064    s0 = GETU32(ct     ) ^ rk[0];
     1065    s1 = GETU32(ct +  4) ^ rk[1];
     1066    s2 = GETU32(ct +  8) ^ rk[2];
     1067    s3 = GETU32(ct + 12) ^ rk[3];
     1068#ifdef FULL_UNROLL
     1069    /* round 1: */
     1070    t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff] ^ Td3[s1 & 0xff] ^ rk[ 4];
     1071    t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff] ^ Td3[s2 & 0xff] ^ rk[ 5];
     1072    t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff] ^ Td3[s3 & 0xff] ^ rk[ 6];
     1073    t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff] ^ Td3[s0 & 0xff] ^ rk[ 7];
     1074    /* round 2: */
     1075    s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>  8) & 0xff] ^ Td3[t1 & 0xff] ^ rk[ 8];
     1076    s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>  8) & 0xff] ^ Td3[t2 & 0xff] ^ rk[ 9];
     1077    s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>  8) & 0xff] ^ Td3[t3 & 0xff] ^ rk[10];
     1078    s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>  8) & 0xff] ^ Td3[t0 & 0xff] ^ rk[11];
     1079    /* round 3: */
     1080    t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff] ^ Td3[s1 & 0xff] ^ rk[12];
     1081    t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff] ^ Td3[s2 & 0xff] ^ rk[13];
     1082    t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff] ^ Td3[s3 & 0xff] ^ rk[14];
     1083    t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff] ^ Td3[s0 & 0xff] ^ rk[15];
     1084    /* round 4: */
     1085    s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>  8) & 0xff] ^ Td3[t1 & 0xff] ^ rk[16];
     1086    s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>  8) & 0xff] ^ Td3[t2 & 0xff] ^ rk[17];
     1087    s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>  8) & 0xff] ^ Td3[t3 & 0xff] ^ rk[18];
     1088    s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>  8) & 0xff] ^ Td3[t0 & 0xff] ^ rk[19];
     1089    /* round 5: */
     1090    t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff] ^ Td3[s1 & 0xff] ^ rk[20];
     1091    t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff] ^ Td3[s2 & 0xff] ^ rk[21];
     1092    t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff] ^ Td3[s3 & 0xff] ^ rk[22];
     1093    t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff] ^ Td3[s0 & 0xff] ^ rk[23];
     1094    /* round 6: */
     1095    s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>  8) & 0xff] ^ Td3[t1 & 0xff] ^ rk[24];
     1096    s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>  8) & 0xff] ^ Td3[t2 & 0xff] ^ rk[25];
     1097    s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>  8) & 0xff] ^ Td3[t3 & 0xff] ^ rk[26];
     1098    s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>  8) & 0xff] ^ Td3[t0 & 0xff] ^ rk[27];
     1099    /* round 7: */
     1100    t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff] ^ Td3[s1 & 0xff] ^ rk[28];
     1101    t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff] ^ Td3[s2 & 0xff] ^ rk[29];
     1102    t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff] ^ Td3[s3 & 0xff] ^ rk[30];
     1103    t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff] ^ Td3[s0 & 0xff] ^ rk[31];
     1104    /* round 8: */
     1105    s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>  8) & 0xff] ^ Td3[t1 & 0xff] ^ rk[32];
     1106    s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>  8) & 0xff] ^ Td3[t2 & 0xff] ^ rk[33];
     1107    s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>  8) & 0xff] ^ Td3[t3 & 0xff] ^ rk[34];
     1108    s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>  8) & 0xff] ^ Td3[t0 & 0xff] ^ rk[35];
     1109    /* round 9: */
     1110    t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff] ^ Td3[s1 & 0xff] ^ rk[36];
     1111    t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff] ^ Td3[s2 & 0xff] ^ rk[37];
     1112    t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff] ^ Td3[s3 & 0xff] ^ rk[38];
     1113    t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff] ^ Td3[s0 & 0xff] ^ rk[39];
     1114    if (Nr > 10) {
     1115        /* round 10: */
     1116        s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>  8) & 0xff] ^ Td3[t1 & 0xff] ^ rk[40];
     1117        s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>  8) & 0xff] ^ Td3[t2 & 0xff] ^ rk[41];
     1118        s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>  8) & 0xff] ^ Td3[t3 & 0xff] ^ rk[42];
     1119        s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>  8) & 0xff] ^ Td3[t0 & 0xff] ^ rk[43];
     1120        /* round 11: */
     1121        t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff] ^ Td3[s1 & 0xff] ^ rk[44];
     1122        t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff] ^ Td3[s2 & 0xff] ^ rk[45];
     1123        t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff] ^ Td3[s3 & 0xff] ^ rk[46];
     1124        t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff] ^ Td3[s0 & 0xff] ^ rk[47];
     1125        if (Nr > 12) {
     1126            /* round 12: */
     1127            s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>  8) & 0xff] ^ Td3[t1 & 0xff] ^ rk[48];
     1128            s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>  8) & 0xff] ^ Td3[t2 & 0xff] ^ rk[49];
     1129            s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>  8) & 0xff] ^ Td3[t3 & 0xff] ^ rk[50];
     1130            s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>  8) & 0xff] ^ Td3[t0 & 0xff] ^ rk[51];
     1131            /* round 13: */
     1132            t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff] ^ Td3[s1 & 0xff] ^ rk[52];
     1133            t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff] ^ Td3[s2 & 0xff] ^ rk[53];
     1134            t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff] ^ Td3[s3 & 0xff] ^ rk[54];
     1135            t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff] ^ Td3[s0 & 0xff] ^ rk[55];
     1136        }
     1137    }
     1138        rk += Nr << 2;
     1139#else  /* !FULL_UNROLL */
     1140    /*
     1141     * Nr - 1 full rounds:
     1142     */
     1143    r = Nr >> 1;
     1144    for (;;) {
     1145        t0 =
     1146            Td0[(s0 >> 24)       ] ^
     1147            Td1[(s3 >> 16) & 0xff] ^
     1148            Td2[(s2 >>  8) & 0xff] ^
     1149            Td3[(s1      ) & 0xff] ^
     1150            rk[4];
     1151        t1 =
     1152            Td0[(s1 >> 24)       ] ^
     1153            Td1[(s0 >> 16) & 0xff] ^
     1154            Td2[(s3 >>  8) & 0xff] ^
     1155            Td3[(s2      ) & 0xff] ^
     1156            rk[5];
     1157        t2 =
     1158            Td0[(s2 >> 24)       ] ^
     1159            Td1[(s1 >> 16) & 0xff] ^
     1160            Td2[(s0 >>  8) & 0xff] ^
     1161            Td3[(s3      ) & 0xff] ^
     1162            rk[6];
     1163        t3 =
     1164            Td0[(s3 >> 24)       ] ^
     1165            Td1[(s2 >> 16) & 0xff] ^
     1166            Td2[(s1 >>  8) & 0xff] ^
     1167            Td3[(s0      ) & 0xff] ^
     1168            rk[7];
     1169
     1170        rk += 8;
     1171        if (--r == 0) {
     1172            break;
     1173        }
     1174
     1175        s0 =
     1176            Td0[(t0 >> 24)       ] ^
     1177            Td1[(t3 >> 16) & 0xff] ^
     1178            Td2[(t2 >>  8) & 0xff] ^
     1179            Td3[(t1      ) & 0xff] ^
     1180            rk[0];
     1181        s1 =
     1182            Td0[(t1 >> 24)       ] ^
     1183            Td1[(t0 >> 16) & 0xff] ^
     1184            Td2[(t3 >>  8) & 0xff] ^
     1185            Td3[(t2      ) & 0xff] ^
     1186            rk[1];
     1187        s2 =
     1188            Td0[(t2 >> 24)       ] ^
     1189            Td1[(t1 >> 16) & 0xff] ^
     1190            Td2[(t0 >>  8) & 0xff] ^
     1191            Td3[(t3      ) & 0xff] ^
     1192            rk[2];
     1193        s3 =
     1194            Td0[(t3 >> 24)       ] ^
     1195            Td1[(t2 >> 16) & 0xff] ^
     1196            Td2[(t1 >>  8) & 0xff] ^
     1197            Td3[(t0      ) & 0xff] ^
     1198            rk[3];
     1199    }
     1200#endif /* ?FULL_UNROLL */
     1201    /*
     1202         * apply last round and
     1203         * map cipher state to byte array block:
     1204         */
     1205        s0 =
     1206                (Td4[(t0 >> 24)       ] & 0xff000000) ^
     1207                (Td4[(t3 >> 16) & 0xff] & 0x00ff0000) ^
     1208                (Td4[(t2 >>  8) & 0xff] & 0x0000ff00) ^
     1209                (Td4[(t1      ) & 0xff] & 0x000000ff) ^
     1210                rk[0];
     1211        PUTU32(pt     , s0);
     1212        s1 =
     1213                (Td4[(t1 >> 24)       ] & 0xff000000) ^
     1214                (Td4[(t0 >> 16) & 0xff] & 0x00ff0000) ^
     1215                (Td4[(t3 >>  8) & 0xff] & 0x0000ff00) ^
     1216                (Td4[(t2      ) & 0xff] & 0x000000ff) ^
     1217                rk[1];
     1218        PUTU32(pt +  4, s1);
     1219        s2 =
     1220                (Td4[(t2 >> 24)       ] & 0xff000000) ^
     1221                (Td4[(t1 >> 16) & 0xff] & 0x00ff0000) ^
     1222                (Td4[(t0 >>  8) & 0xff] & 0x0000ff00) ^
     1223                (Td4[(t3      ) & 0xff] & 0x000000ff) ^
     1224                rk[2];
     1225        PUTU32(pt +  8, s2);
     1226        s3 =
     1227                (Td4[(t3 >> 24)       ] & 0xff000000) ^
     1228                (Td4[(t2 >> 16) & 0xff] & 0x00ff0000) ^
     1229                (Td4[(t1 >>  8) & 0xff] & 0x0000ff00) ^
     1230                (Td4[(t0      ) & 0xff] & 0x000000ff) ^
     1231                rk[3];
     1232        PUTU32(pt + 12, s3);
    4631233}
    464 #endif /* INTERMEDIATE_VALUE_KAT */
     1234
    4651235#endif

  • trunk/src/rijndael-api-fst.c

    r230 r481  
    1 /*
    2  * rijndael-api-fst.c   v2.3   April '2000
    3  *
    4  * Optimised ANSI C code
    5  *
    6  * authors: v1.0: Antoon Bosselaers
    7  *          v2.0: Vincent Rijmen
    8  *          v2.1: Vincent Rijmen
    9  *          v2.2: Vincent Rijmen
    10  *          v2.3: Paulo Barreto
    11  *          v2.4: Vincent Rijmen
    12  *
    13  * This code is placed in the public domain.
     1/*      $NetBSD: rijndael-api-fst.c,v 1.24 2011/05/14 16:46:55 jmmv Exp $       */
     2
     3/**
     4 * rijndael-api-fst.c
     5 *
     6 * @version 2.9 (December 2000)
     7 *
     8 * Optimised ANSI C code for the Rijndael cipher (now AES)
     9 *
     10 * @author Vincent Rijmen <vincent.rijmen@esat.kuleuven.ac.be>
     11 * @author Antoon Bosselaers <antoon.bosselaers@esat.kuleuven.ac.be>
     12 * @author Paulo Barreto <paulo.barreto@terra.com.br>
     13 *
     14 * This code is hereby placed in the public domain.
     15 *
     16 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ''AS IS'' AND ANY EXPRESS
     17 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE
     20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
     23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
     25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
     26 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27 *
     28 * Acknowledgements:
     29 *
     30 * We are deeply indebted to the following people for their bug reports,
     31 * fixes, and improvement suggestions to this implementation. Though we
     32 * tried to list all contributions, we apologise in advance for any
     33 * missing reference.
     34 *
     35 * Andrew Bales <Andrew.Bales@Honeywell.com>
     36 * Markus Friedl <markus.friedl@informatik.uni-erlangen.de>
     37 * John Skodon <skodonj@webquill.com>
    1438 */
    15 
    1639#include "config_xor.h"
    1740
    18 #include <stdio.h>
    19 #include <assert.h>
    2041#include <stdlib.h>
    2142#include <string.h>
    2243
     44
    2345#ifdef SH_ENCRYPT
    2446
    2547#include "rijndael-api-fst.h"
    2648
    27 int makeKey(keyInstance *key, RIJ_BYTE direction, int keyLen, char *keyMaterial) {
    28   word8 k[MAXKC][4];
    29   int i;
    30   char *keyMat;
    31  
    32   if (key == NULL) {
    33     return BAD_KEY_INSTANCE;
    34   }
    35  
    36   if ((direction == DIR_ENCRYPT) || (direction == DIR_DECRYPT)) {
    37     key->direction = direction;
    38   } else {
    39     return BAD_KEY_DIR;
    40   }
    41  
    42   if ((keyLen == 128) || (keyLen == 192) || (keyLen == 256)) {
    43     key->keyLen = keyLen;
    44   } else {
    45     return BAD_KEY_MAT;
    46   }
    47  
    48   if (keyMaterial != NULL) {
    49     strncpy(key->keyMaterial, keyMaterial, keyLen/4);
    50   }
    51  
    52   key->ROUNDS = keyLen/32 + 6;
    53  
    54   /* initialize key schedule: */
    55   keyMat = key->keyMaterial;
    56 #ifndef BINARY_KEY_MATERIAL
    57   for (i = 0; i < key->keyLen/8; i++) {
    58     int t, j;
    59    
    60     t = *keyMat++;
    61     if ((t >= '0') && (t <= '9')) j = (t - '0') << 4;
    62     else if ((t >= 'a') && (t <= 'f')) j = (t - 'a' + 10) << 4;
    63     else if ((t >= 'A') && (t <= 'F')) j = (t - 'A' + 10) << 4;
    64     else return BAD_KEY_MAT;
    65    
    66     t = *keyMat++;
    67     if ((t >= '0') && (t <= '9')) j ^= (t - '0');
    68     else if ((t >= 'a') && (t <= 'f')) j ^= (t - 'a' + 10);
    69     else if ((t >= 'A') && (t <= 'F')) j ^= (t - 'A' + 10);
    70     else return BAD_KEY_MAT;
    71    
    72     k[i >> 2][i & 3] = (word8)j;
    73   }
    74 #else
    75   for (i = 0; i < key->keyLen/8; i++) {
    76     k[i >> 2][i & 3] = (word8)keyMat[i];
    77   }
    78 #endif /* ?BINARY_KEY_MATERIAL */
    79   rijndaelKeySched(k, key->keySched, key->ROUNDS);
    80   if (direction == DIR_DECRYPT) {
    81     rijndaelKeyEncToDec(key->keySched, key->ROUNDS);
    82   }
    83  
    84   return TRUE;
    85 }
    86 
    87 int cipherInit(cipherInstance *cipher, RIJ_BYTE mode, char *IV) {
    88   if ((mode == MODE_ECB) || (mode == MODE_CBC) || (mode == MODE_CFB1)) {
    89     cipher->mode = mode;
    90   } else {
    91     return BAD_CIPHER_MODE;
    92   }
    93   if (IV != NULL) {
    94 #ifndef BINARY_KEY_MATERIAL
    95     int i;
    96     for (i = 0; i < MAX_IV_SIZE; i++) {
    97       int t, j;
    98      
    99       t = IV[2*i];
    100       if ((t >= '0') && (t <= '9')) j = (t - '0') << 4;
    101       else if ((t >= 'a') && (t <= 'f')) j = (t - 'a' + 10) << 4;
    102       else if ((t >= 'A') && (t <= 'F')) j = (t - 'A' + 10) << 4;
    103       else return BAD_CIPHER_INSTANCE;
    104      
    105       t = IV[2*i+1];
    106       if ((t >= '0') && (t <= '9')) j ^= (t - '0');
    107       else if ((t >= 'a') && (t <= 'f')) j ^= (t - 'a' + 10);
    108       else if ((t >= 'A') && (t <= 'F')) j ^= (t - 'A' + 10);
    109       else return BAD_CIPHER_INSTANCE;
    110      
    111       cipher->IV[i] = (word8)j;
    112     }
    113 #else
    114     memcpy(cipher->IV, IV, MAX_IV_SIZE);
    115 #endif /* ?BINARY_KEY_MATERIAL */
    116   } else {
    117     memset(cipher->IV, 0, MAX_IV_SIZE);
    118   }
    119   return TRUE;
    120 }
    121 
    122 int blockEncrypt(cipherInstance *cipher, keyInstance *key,
    123                  RIJ_BYTE *input, int inputLen, RIJ_BYTE *outBuffer) {
    124   int i, k, numBlocks;
    125   union {
    126     word32 bloc4[4];
    127     word8  block[16];
    128   } bb;
    129   union {
    130     word32 i4[4];
    131     word8  iv[4][4];
    132   } iu;
    133  
    134   if (cipher == NULL ||
    135       key == NULL ||
    136       key->direction == DIR_DECRYPT) {
    137     return BAD_CIPHER_STATE;
    138   }
    139   if (input == NULL || inputLen <= 0) {
    140     return 0; /* nothing to do */
    141   }
    142  
    143   numBlocks = inputLen/128;
    144  
    145   switch (cipher->mode) {
    146   case MODE_ECB:
    147     for (i = numBlocks; i > 0; i--) {
    148       rijndaelEncrypt(input, outBuffer, key->keySched, key->ROUNDS);
    149       input += 16;
    150       outBuffer += 16;
    151     }
    152     break;
    153    
    154   case MODE_CBC:
    155     /* fix the memory alignment for HP-UX 10.20
    156      * R. Wichmann  Mon Jun 18 22:36:55 CEST 2001
    157      */
    158 #if STRICT_ALIGN
    159     memcpy(iu.iv, cipher->IV, 16);
    160     bb.bloc4[0] = iu.i4[0] ^ ((word32*)input)[0];
    161     bb.bloc4[1] = iu.i4[1] ^ ((word32*)input)[1];
    162     bb.bloc4[2] = iu.i4[2] ^ ((word32*)input)[2];
    163     bb.bloc4[3] = iu.i4[3] ^ ((word32*)input)[3];
    164 #else  /* !STRICT_ALIGN */
    165     ((word32*)block)[0] = ((word32*)cipher->IV)[0] ^ ((word32*)input)[0];
    166     ((word32*)block)[1] = ((word32*)cipher->IV)[1] ^ ((word32*)input)[1];
    167     ((word32*)block)[2] = ((word32*)cipher->IV)[2] ^ ((word32*)input)[2];
    168     ((word32*)block)[3] = ((word32*)cipher->IV)[3] ^ ((word32*)input)[3];
    169 #endif /* ?STRICT_ALIGN */
    170     rijndaelEncrypt(bb.block, outBuffer, key->keySched, key->ROUNDS);
    171     input += 16;
    172     for (i = numBlocks - 1; i > 0; i--) {
    173       bb.bloc4[0] = ((word32*)outBuffer)[0] ^ ((word32*)input)[0];
    174       bb.bloc4[1] = ((word32*)outBuffer)[1] ^ ((word32*)input)[1];
    175       bb.bloc4[2] = ((word32*)outBuffer)[2] ^ ((word32*)input)[2];
    176       bb.bloc4[3] = ((word32*)outBuffer)[3] ^ ((word32*)input)[3];
    177       outBuffer += 16;
    178       rijndaelEncrypt(bb.block, outBuffer, key->keySched, key->ROUNDS);
    179       input += 16;
    180     }
    181     break;
    182    
    183   case MODE_CFB1:
    184 #if STRICT_ALIGN
    185     memcpy(iu.iv, cipher->IV, 16);
    186 #else  /* !STRICT_ALIGN */
    187     *((word32*)iv[0]) = *((word32*)(cipher->IV   ));
    188     *((word32*)iv[1]) = *((word32*)(cipher->IV+ 4));
    189     *((word32*)iv[2]) = *((word32*)(cipher->IV+ 8));
    190     *((word32*)iv[3]) = *((word32*)(cipher->IV+12));
    191 #endif /* ?STRICT_ALIGN */
    192     for (i = numBlocks; i > 0; i--) {
    193       for (k = 0; k < 128; k++) {
    194         bb.bloc4[0] = iu.i4[0];
    195         bb.bloc4[1] = iu.i4[1];
    196         bb.bloc4[2] = iu.i4[2];
    197         bb.bloc4[3] = iu.i4[3];
    198         rijndaelEncrypt(bb.block, bb.block, key->keySched, key->ROUNDS);
    199         outBuffer[k/8] ^= (bb.block[0] & 0x80) >> (k & 7);
    200         iu.iv[0][0] = (iu.iv[0][0] << 1) | (iu.iv[0][1] >> 7);
    201         iu.iv[0][1] = (iu.iv[0][1] << 1) | (iu.iv[0][2] >> 7);
    202         iu.iv[0][2] = (iu.iv[0][2] << 1) | (iu.iv[0][3] >> 7);
    203         iu.iv[0][3] = (iu.iv[0][3] << 1) | (iu.iv[1][0] >> 7);
    204         iu.iv[1][0] = (iu.iv[1][0] << 1) | (iu.iv[1][1] >> 7);
    205         iu.iv[1][1] = (iu.iv[1][1] << 1) | (iu.iv[1][2] >> 7);
    206         iu.iv[1][2] = (iu.iv[1][2] << 1) | (iu.iv[1][3] >> 7);
    207         iu.iv[1][3] = (iu.iv[1][3] << 1) | (iu.iv[2][0] >> 7);
    208         iu.iv[2][0] = (iu.iv[2][0] << 1) | (iu.iv[2][1] >> 7);
    209         iu.iv[2][1] = (iu.iv[2][1] << 1) | (iu.iv[2][2] >> 7);
    210         iu.iv[2][2] = (iu.iv[2][2] << 1) | (iu.iv[2][3] >> 7);
    211         iu.iv[2][3] = (iu.iv[2][3] << 1) | (iu.iv[3][0] >> 7);
    212         iu.iv[3][0] = (iu.iv[3][0] << 1) | (iu.iv[3][1] >> 7);
    213         iu.iv[3][1] = (iu.iv[3][1] << 1) | (iu.iv[3][2] >> 7);
    214         iu.iv[3][2] = (iu.iv[3][2] << 1) | (iu.iv[3][3] >> 7);
    215         iu.iv[3][3] = (iu.iv[3][3] << 1) | ((outBuffer[k/8] >> (7-(k&7))) & 1);
    216       }
    217     }
    218     break;
    219    
    220   default:
    221     return BAD_CIPHER_STATE;
    222   }
    223  
    224   return 128*numBlocks;
    225 }
    226 
    227 int blockDecrypt(cipherInstance *cipher, keyInstance *key,
    228                  RIJ_BYTE *input, int inputLen, RIJ_BYTE *outBuffer) {
    229   int i, k, numBlocks;
    230   union {
    231     word32 bloc4[4];
    232     word8  block[16];
    233   } bb;
    234   union {
    235     word32 i4[4];
    236     word8  iv[4][4];
    237   } iu;
    238  
    239   if (cipher == NULL ||
    240       key == NULL ||
    241       ((cipher->mode != MODE_CFB1) && (key->direction == DIR_ENCRYPT))) {
    242     return BAD_CIPHER_STATE;
    243   }
    244   if (input == NULL || inputLen <= 0) {
    245     return 0; /* nothing to do */
    246   }
    247  
    248   numBlocks = inputLen/128;
    249  
    250   switch (cipher->mode) {
    251   case MODE_ECB:
    252     for (i = numBlocks; i > 0; i--) {
    253       rijndaelDecrypt(input, outBuffer, key->keySched, key->ROUNDS);
    254       input += 16;
    255       outBuffer += 16;
    256     }
    257     break;
    258    
    259   case MODE_CBC:
    260 #if STRICT_ALIGN
    261     memcpy(iu.iv, cipher->IV, 16);
    262 #else
    263     *((word32*)iu.i4[0]) = *((word32*)(cipher->IV   ));
    264     *((word32*)iu.i4[1]) = *((word32*)(cipher->IV+ 4));
    265     *((word32*)iu.i4[2]) = *((word32*)(cipher->IV+ 8));
    266     *((word32*)iu.i4[3]) = *((word32*)(cipher->IV+12));
     49static void xor16(u8 *d, const u8 *a, const u8* b)
     50{
     51  size_t i;
     52
     53        for (i = 0; i < 4; i++) {
     54                *d++ = *a++ ^ *b++;
     55                *d++ = *a++ ^ *b++;
     56                *d++ = *a++ ^ *b++;
     57                *d++ = *a++ ^ *b++;
     58        }
     59}
     60
     61int
     62rijndael_makeKey(keyInstance *key, BYTE direction, int keyLen,
     63    const char *keyMaterial)
     64{
     65        u8 cipherKey[RIJNDAEL_MAXKB];
     66        int i;
     67
     68        if (key == NULL) {
     69                return BAD_KEY_INSTANCE;
     70        }
     71
     72        if ((direction == DIR_ENCRYPT) || (direction == DIR_DECRYPT)) {
     73                key->direction = direction;
     74        } else {
     75                return BAD_KEY_DIR;
     76        }
     77
     78        if ((keyLen == 128) || (keyLen == 192) || (keyLen == 256)) {
     79                key->keyLen = keyLen;
     80        } else {
     81                return BAD_KEY_MAT;
     82        }
     83
     84        if (keyMaterial != NULL) {
     85                char temp[RIJNDAEL_MAX_KEY_SIZE];
     86                for (i = 0; i < key->keyLen/8; i++) {
     87                  int t, j;
     88                 
     89                  t = *keyMaterial++;
     90                  if ((t >= '0') && (t <= '9')) j = (t - '0') << 4;
     91                  else if ((t >= 'a') && (t <= 'f')) j = (t - 'a' + 10) << 4;
     92                  else if ((t >= 'A') && (t <= 'F')) j = (t - 'A' + 10) << 4;
     93                  else return BAD_KEY_MAT;
     94                 
     95                  t = *keyMaterial++;
     96                  if ((t >= '0') && (t <= '9')) j ^= (t - '0');
     97                  else if ((t >= 'a') && (t <= 'f')) j ^= (t - 'a' + 10);
     98                  else if ((t >= 'A') && (t <= 'F')) j ^= (t - 'A' + 10);
     99                  else return BAD_KEY_MAT;
     100                 
     101                  temp[i] = (u8)j;
     102                }
     103
     104                /* memcpy(key->keyMaterial, keyMaterial, keyLen/8); */
     105                memcpy(key->keyMaterial, temp, keyLen/8);
     106        }
     107
     108        /* initialize key schedule: */
     109        memcpy(cipherKey, key->keyMaterial, keyLen/8);
     110        if (direction == DIR_ENCRYPT) {
     111                key->Nr = rijndaelKeySetupEnc(key->rk, cipherKey, keyLen);
     112        } else {
     113                key->Nr = rijndaelKeySetupDec(key->rk, cipherKey, keyLen);
     114        }
     115        rijndaelKeySetupEnc(key->ek, cipherKey, keyLen);
     116        return TRUE;
     117}
     118
     119int
     120rijndael_cipherInit(cipherInstance *cipher, BYTE mode, const char *IV)
     121{
     122        if ((mode == MODE_ECB) || (mode == MODE_CBC) || (mode == MODE_CFB1)) {
     123                cipher->mode = mode;
     124        } else {
     125                return BAD_CIPHER_MODE;
     126        }
     127        if (IV != NULL) {
     128                memcpy(cipher->IV, IV, RIJNDAEL_MAX_IV_SIZE);
     129        } else {
     130                memset(cipher->IV, 0, RIJNDAEL_MAX_IV_SIZE);
     131        }
     132        return TRUE;
     133}
     134
     135int
     136rijndael_blockEncrypt(cipherInstance *cipher, keyInstance *key,
     137    const BYTE *input, int inputLen, BYTE *outBuffer)
     138{
     139        int i, k, t, numBlocks;
     140        u8 block[16], *iv;
     141
     142        if (cipher == NULL ||
     143                key == NULL ||
     144                key->direction == DIR_DECRYPT) {
     145                return BAD_CIPHER_STATE;
     146        }
     147        if (input == NULL || inputLen <= 0) {
     148                return 0; /* nothing to do */
     149        }
     150
     151        numBlocks = inputLen/128;
     152
     153        switch (cipher->mode) {
     154        case MODE_ECB:
     155                for (i = numBlocks; i > 0; i--) {
     156                        rijndaelEncrypt(key->rk, key->Nr, input, outBuffer);
     157                        input += 16;
     158                        outBuffer += 16;
     159                }
     160                break;
     161
     162        case MODE_CBC:
     163                iv = (u8 *)cipher->IV;
     164                for (i = numBlocks; i > 0; i--) {
     165                        xor16(block, input, iv);
     166                        rijndaelEncrypt(key->rk, key->Nr, block, outBuffer);
     167                        iv = outBuffer;
     168                        input += 16;
     169                        outBuffer += 16;
     170                }
     171                break;
     172
     173        case MODE_CFB1:
     174                iv = (u8 *)cipher->IV;
     175                for (i = numBlocks; i > 0; i--) {
     176                        memcpy(outBuffer, input, 16);
     177                        for (k = 0; k < 128; k++) {
     178                                rijndaelEncrypt(key->ek, key->Nr, iv, block);
     179                                outBuffer[k >> 3] ^=
     180                                    (block[0] & 0x80U) >> (k & 7);
     181                                for (t = 0; t < 15; t++) {
     182                                        iv[t] = (iv[t] << 1) | (iv[t + 1] >> 7);
     183                                }
     184                                iv[15] = (iv[15] << 1) |
     185                                    ((outBuffer[k >> 3] >> (7 - (k & 7))) & 1);
     186                        }
     187                        outBuffer += 16;
     188                        input += 16;
     189                }
     190                break;
     191
     192        default:
     193                return BAD_CIPHER_STATE;
     194        }
     195
     196        return 128 * numBlocks;
     197}
     198
     199/**
     200 * Encrypt data partitioned in octets, using RFC 2040-like padding.
     201 *
     202 * @param   input           data to be encrypted (octet sequence)
     203 * @param   inputOctets         input length in octets (not bits)
     204 * @param   outBuffer       encrypted output data
     205 *
     206 * @return      length in octets (not bits) of the encrypted output buffer.
     207 */
     208int
     209rijndael_padEncrypt(cipherInstance *cipher, keyInstance *key,
     210    const BYTE *input, int inputOctets, BYTE *outBuffer)
     211{
     212        int i, numBlocks, padLen;
     213        u8 block[16], *iv;
     214
     215        if (cipher == NULL ||
     216                key == NULL ||
     217                key->direction == DIR_DECRYPT) {
     218                return BAD_CIPHER_STATE;
     219        }
     220        if (input == NULL || inputOctets <= 0) {
     221                return 0; /* nothing to do */
     222        }
     223
     224        numBlocks = inputOctets / 16;
     225
     226        switch (cipher->mode) {
     227        case MODE_ECB:
     228                for (i = numBlocks; i > 0; i--) {
     229                        rijndaelEncrypt(key->rk, key->Nr, input, outBuffer);
     230                        input += 16;
     231                        outBuffer += 16;
     232                }
     233                padLen = 16 - (inputOctets - 16*numBlocks);
     234                memcpy(block, input, 16 - padLen);
     235                memset(block + 16 - padLen, padLen, padLen);
     236                rijndaelEncrypt(key->rk, key->Nr, block, outBuffer);
     237                break;
     238
     239        case MODE_CBC:
     240                iv = (u8 *)cipher->IV;
     241                for (i = numBlocks; i > 0; i--) {
     242                        xor16(block, input, iv);
     243                        rijndaelEncrypt(key->rk, key->Nr, block, outBuffer);
     244                        iv = outBuffer;
     245                        input += 16;
     246                        outBuffer += 16;
     247                }
     248                padLen = 16 - (inputOctets - 16*numBlocks);
     249                for (i = 0; i < 16 - padLen; i++) {
     250                        block[i] = input[i] ^ iv[i];
     251                }
     252                for (i = 16 - padLen; i < 16; i++) {
     253                        block[i] = (BYTE)padLen ^ iv[i];
     254                }
     255                rijndaelEncrypt(key->rk, key->Nr, block, outBuffer);
     256                break;
     257
     258        default:
     259                return BAD_CIPHER_STATE;
     260        }
     261
     262        return 16 * (numBlocks + 1);
     263}
     264
     265int
     266rijndael_blockDecrypt(cipherInstance *cipher, keyInstance *key,
     267    const BYTE *input, int inputLen, BYTE *outBuffer)
     268{
     269        int i, k, t, numBlocks;
     270        u8 block[16], *iv;
     271
     272        if (cipher == NULL ||
     273                key == NULL ||
     274                (cipher->mode != MODE_CFB1 && key->direction == DIR_ENCRYPT)) {
     275                return BAD_CIPHER_STATE;
     276        }
     277        if (input == NULL || inputLen <= 0) {
     278                return 0; /* nothing to do */
     279        }
     280
     281        numBlocks = inputLen/128;
     282
     283        switch (cipher->mode) {
     284        case MODE_ECB:
     285                for (i = numBlocks; i > 0; i--) {
     286                        rijndaelDecrypt(key->rk, key->Nr, input, outBuffer);
     287                        input += 16;
     288                        outBuffer += 16;
     289                }
     290                break;
     291
     292        case MODE_CBC:
     293                iv = (u8 *)cipher->IV;
     294                for (i = numBlocks; i > 0; i--) {
     295                        rijndaelDecrypt(key->rk, key->Nr, input, block);
     296                        xor16(block, block, iv);
     297                        if (numBlocks > 1)
     298                          memcpy(cipher->IV, input, 16);
     299                        memcpy(outBuffer, block, 16);
     300                        input += 16;
     301                        outBuffer += 16;
     302                }
     303                break;
     304
     305    case MODE_CFB1:
     306                iv = (u8 *)cipher->IV;
     307                for (i = numBlocks; i > 0; i--) {
     308                        memcpy(outBuffer, input, 16);
     309                        for (k = 0; k < 128; k++) {
     310                                rijndaelEncrypt(key->ek, key->Nr, iv, block);
     311                                for (t = 0; t < 15; t++) {
     312                                        iv[t] = (iv[t] << 1) | (iv[t + 1] >> 7);
     313                                }
     314                                iv[15] = (iv[15] << 1) |
     315                                    ((input[k >> 3] >> (7 - (k & 7))) & 1);
     316                                outBuffer[k >> 3] ^= (block[0] & 0x80U) >>
     317                                    (k & 7);
     318                        }
     319                        outBuffer += 16;
     320                        input += 16;
     321                }
     322                break;
     323
     324        default:
     325                return BAD_CIPHER_STATE;
     326        }
     327
     328        return 128 * numBlocks;
     329}
     330
     331int
     332rijndael_padDecrypt(cipherInstance *cipher, keyInstance *key,
     333    const BYTE *input, int inputOctets, BYTE *outBuffer)
     334{
     335        int i, numBlocks, padLen;
     336        u8 block[16], *iv;
     337
     338        if (cipher == NULL ||
     339                key == NULL ||
     340                key->direction == DIR_ENCRYPT) {
     341                return BAD_CIPHER_STATE;
     342        }
     343        if (input == NULL || inputOctets <= 0) {
     344                return 0; /* nothing to do */
     345        }
     346        if (inputOctets % 16 != 0) {
     347                return BAD_DATA;
     348        }
     349
     350        numBlocks = inputOctets/16;
     351
     352        switch (cipher->mode) {
     353        case MODE_ECB:
     354                /* all blocks but last */
     355                for (i = numBlocks - 1; i > 0; i--) {
     356                        rijndaelDecrypt(key->rk, key->Nr, input, outBuffer);
     357                        input += 16;
     358                        outBuffer += 16;
     359                }
     360                /* last block */
     361                rijndaelDecrypt(key->rk, key->Nr, input, block);
     362                padLen = block[15];
     363                if (padLen >= 16) {
     364                        return BAD_DATA;
     365                }
     366                for (i = 16 - padLen; i < 16; i++) {
     367                        if (block[i] != padLen) {
     368                                return BAD_DATA;
     369                        }
     370                }
     371                memcpy(outBuffer, block, 16 - padLen);
     372                break;
     373
     374        case MODE_CBC:
     375                iv = (u8 *)cipher->IV;
     376                /* all blocks but last */
     377                for (i = numBlocks - 1; i > 0; i--) {
     378                        rijndaelDecrypt(key->rk, key->Nr, input, block);
     379                        xor16(block, block, iv);
     380                        memcpy(cipher->IV, input, 16);
     381                        memcpy(outBuffer, block, 16);
     382                        input += 16;
     383                        outBuffer += 16;
     384                }
     385                /* last block */
     386                rijndaelDecrypt(key->rk, key->Nr, input, block);
     387                xor16(block, block, iv);
     388                padLen = block[15];
     389                if (padLen <= 0 || padLen > 16) {
     390                        return BAD_DATA;
     391                }
     392                for (i = 16 - padLen; i < 16; i++) {
     393                        if (block[i] != padLen) {
     394                                return BAD_DATA;
     395                        }
     396                }
     397                memcpy(outBuffer, block, 16 - padLen);
     398                break;
     399
     400        default:
     401                return BAD_CIPHER_STATE;
     402        }
     403
     404        return 16 * numBlocks - padLen;
     405}
     406
    267407#endif
    268     for (i = numBlocks; i > 0; i--) {
    269       rijndaelDecrypt(input, bb.block, key->keySched, key->ROUNDS);
    270       bb.bloc4[0] ^= iu.i4[0];
    271       bb.bloc4[1] ^= iu.i4[1];
    272       bb.bloc4[2] ^= iu.i4[2];
    273       bb.bloc4[3] ^= iu.i4[3];
    274 #if STRICT_ALIGN
    275       memcpy(iu.iv, input, 16);
    276       memcpy(outBuffer, bb.block, 16);
    277 #else
    278       *((word32*)iv[0]) = ((word32*)input)[0]; ((word32*)outBuffer)[0] = ((word32*)block)[0];
    279       *((word32*)iv[1]) = ((word32*)input)[1]; ((word32*)outBuffer)[1] = ((word32*)block)[1];
    280       *((word32*)iv[2]) = ((word32*)input)[2]; ((word32*)outBuffer)[2] = ((word32*)block)[2];
    281       *((word32*)iv[3]) = ((word32*)input)[3]; ((word32*)outBuffer)[3] = ((word32*)block)[3];
    282 #endif
    283       input += 16;
    284       outBuffer += 16;
    285     }
    286     break;
    287    
    288   case MODE_CFB1:
    289 #if STRICT_ALIGN
    290     memcpy(iu.iv, cipher->IV, 16);
    291 #else
    292     *((word32*)iv[0]) = *((word32*)(cipher->IV));
    293     *((word32*)iv[1]) = *((word32*)(cipher->IV+ 4));
    294     *((word32*)iv[2]) = *((word32*)(cipher->IV+ 8));
    295     *((word32*)iv[3]) = *((word32*)(cipher->IV+12));
    296 #endif
    297     for (i = numBlocks; i > 0; i--) {
    298       for (k = 0; k < 128; k++) {
    299         bb.bloc4[0] = iu.i4[0];
    300         bb.bloc4[1] = iu.i4[1];
    301         bb.bloc4[2] = iu.i4[2];
    302         bb.bloc4[3] = iu.i4[3];
    303         rijndaelEncrypt(bb.block, bb.block, key->keySched, key->ROUNDS);
    304         iu.iv[0][0] = (iu.iv[0][0] << 1) | (iu.iv[0][1] >> 7);
    305         iu.iv[0][1] = (iu.iv[0][1] << 1) | (iu.iv[0][2] >> 7);
    306         iu.iv[0][2] = (iu.iv[0][2] << 1) | (iu.iv[0][3] >> 7);
    307         iu.iv[0][3] = (iu.iv[0][3] << 1) | (iu.iv[1][0] >> 7);
    308         iu.iv[1][0] = (iu.iv[1][0] << 1) | (iu.iv[1][1] >> 7);
    309         iu.iv[1][1] = (iu.iv[1][1] << 1) | (iu.iv[1][2] >> 7);
    310         iu.iv[1][2] = (iu.iv[1][2] << 1) | (iu.iv[1][3] >> 7);
    311         iu.iv[1][3] = (iu.iv[1][3] << 1) | (iu.iv[2][0] >> 7);
    312         iu.iv[2][0] = (iu.iv[2][0] << 1) | (iu.iv[2][1] >> 7);
    313         iu.iv[2][1] = (iu.iv[2][1] << 1) | (iu.iv[2][2] >> 7);
    314         iu.iv[2][2] = (iu.iv[2][2] << 1) | (iu.iv[2][3] >> 7);
    315         iu.iv[2][3] = (iu.iv[2][3] << 1) | (iu.iv[3][0] >> 7);
    316         iu.iv[3][0] = (iu.iv[3][0] << 1) | (iu.iv[3][1] >> 7);
    317         iu.iv[3][1] = (iu.iv[3][1] << 1) | (iu.iv[3][2] >> 7);
    318         iu.iv[3][2] = (iu.iv[3][2] << 1) | (iu.iv[3][3] >> 7);
    319         iu.iv[3][3] = (iu.iv[3][3] << 1) | ((input[k/8] >> (7-(k&7))) & 1);
    320         outBuffer[k/8] ^= (bb.block[0] & 0x80) >> (k & 7);
    321       }
    322     }
    323     break;
    324    
    325   default:
    326     return BAD_CIPHER_STATE;
    327   }
    328  
    329   return 128*numBlocks;
    330 }
    331 #ifdef INTERMEDIATE_VALUE_KAT
    332 /**
    333  *      cipherUpdateRounds:
    334  *
    335  *      Encrypts/Decrypts exactly one full block a specified number of rounds.
    336  *      Only used in the Intermediate Value Known Answer Test. 
    337  *
    338  *      Returns:
    339  *              TRUE - on success
    340  *              BAD_CIPHER_STATE - cipher in bad state (e.g., not initialized)
    341  */
    342 int cipherUpdateRounds(cipherInstance *cipher, keyInstance *key,
    343                 RIJ_BYTE *input, int inputLen, RIJ_BYTE *outBuffer, int rounds) {
    344         int j;
    345         word8 block[4][4];
    346 
    347         if (cipher == NULL || key == NULL) {
    348                 return BAD_CIPHER_STATE;
    349         }
    350 
    351         for (j = 3; j >= 0; j--) {
    352                 /* parse input stream into rectangular array */
    353                 *((word32*)block[j]) = *((word32*)(input+4*j));
    354         }
    355 
    356         switch (key->direction) {
    357         case DIR_ENCRYPT:
    358                 rijndaelEncryptRound(block, key->keySched, key->ROUNDS, rounds);
    359                 break;
    360                
    361         case DIR_DECRYPT:
    362                 rijndaelDecryptRound(block, key->keySched, key->ROUNDS, rounds);
    363                 break;
    364                
    365         default:
    366                 return BAD_KEY_DIR;
    367         }
    368 
    369         for (j = 3; j >= 0; j--) {
    370                 /* parse rectangular array into output ciphertext bytes */
    371                 *((word32*)(outBuffer+4*j)) = *((word32*)block[j]);
    372         }
    373        
    374         return TRUE;
    375 }
    376 #endif /* INTERMEDIATE_VALUE_KAT */
    377 #endif

  • trunk/src/samhain.c

    r473 r481  
    7171#include "sh_readconf.h"
    7272#include "sh_hash.h"
     73#include "sh_dbIO.h"
    7374#include "sh_restrict.h"
    7475
    … …  
    7879#include "sh_gpg.h"
    7980#include "sh_mem.h"
    80 #include "sh_forward.h"
     81#include "sh_xfer.h"
    8182#include "sh_tools.h"
    8283#include "sh_hash.h"
    … …  
    8889#include "sh_ignore.h"
    8990#include "sh_prelink.h"
     91#include "sh_sem.h"
    9092#endif
    9193
    … …  
    120122volatile  int      sig_termfast;           /* SIGTERM */
    121123volatile  int      sig_force_check;        /* SIGTTOU */
     124volatile  int      sh_load_delta_flag;
    122125long int           eintr__result;
    123126char               sh_sig_msg[SH_MINIBUF];
    … …  
    313316  ErrFlag[0] |= (1 << 11);
    314317#endif
     318
     319  sh.delayload = 0;
     320
    315321#ifdef MKA_13
    316322  ErrFlag[0] |= (1 << 12);
    … …  
    337343  sig_termfast           = 0;           /* SIGTERM */
    338344  sig_force_check        = 0;           /* SIGTTOU */
     345  sh_load_delta_flag     = 0;
    339346  strcpy ( sh_sig_msg, _("None"));
    340347
    … …  
    373380
    374381  sh.pid = (UINT64) getpid();
     382
     383  sh.outpath = NULL;
    375384
    376385  /* The flags.
    … …  
    647656    {
    648657
    649       skey->mlock_failed = SL_FALSE;
     658      skey->mlock_failed = S_FALSE;
    650659      skey->rngI         = BAD;
    651660      /* properly initialized later
    … …  
    718727#endif
    719728
    720   SL_ENTER(_("exit_handler"));
    721 
    722729#if defined(SH_WITH_SERVER)
    723730  sh_socket_remove ();
    … …  
    751758   */
    752759  sh_html_zero();
    753   /* sh_forward_html_write(); */
    754760#endif
    755761
    … …  
    775781#endif
    776782#if defined(SH_WITH_SERVER)
    777   sh_forward_free_all ();
     783  sh_xfer_free_all ();
    778784#endif
    779785#if defined(SH_WITH_MAIL)
    … …  
    796802  /* --- Exit Message. ---
    797803   */
     804  if (sh.flag.exit == EXIT_FAILURE && !strcmp(sh_sig_msg, _("None")))
     805    sl_strlcpy(sh_sig_msg, _("exit_failure"), SH_MINIBUF);
     806  if (sh.flag.exit == EXIT_SUCCESS && !strcmp(sh_sig_msg, _("None")))
     807    sl_strlcpy(sh_sig_msg, _("exit_success"), SH_MINIBUF);
    798808  sh_error_handle ((-1), FIL__, __LINE__, sh.flag.exit, MSG_EXIT_NORMAL,
    799809                   sh.prg_name, sh_sig_msg);
    … …  
    805815  /* --- Restrict error logging to stderr. ---
    806816   */
    807 #ifdef WITH_MESSAGE_QUEUE
    808817  close_ipc ();
    809 #endif
    810818  sh_error_only_stderr (S_TRUE);
    811 
    812819
    813820  /* --- Remove lock, delete critical information. ---
    … …  
    12151222}
    12161223
     1224
     1225void do_reconf()
     1226{
     1227  int status, modnum;
     1228
     1229  sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_RECONF);
     1230 
     1231  sh_thread_pause_flag = S_TRUE;
     1232 
     1233#if defined(WITH_EXTERNAL)
     1234  /* delete list of external tasks
     1235   */
     1236  (void) sh_ext_cleanup();
     1237#endif
     1238#if defined(SH_WITH_MAIL)
     1239  sh_nmail_free();
     1240#endif
     1241 
     1242  /* delete the file list, make all database
     1243   * entries visible (allignore = FALSE)
     1244   */
     1245  (void) sh_files_deldirstack ();
     1246  (void) sh_files_delfilestack ();
     1247  (void) sh_files_delglobstack ();
     1248  (void) sh_ignore_clean ();
     1249  (void) hash_full_tree ();
     1250  sh_audit_delete_all ();
     1251 
     1252 
     1253#if defined(SH_WITH_CLIENT)
     1254  reset_count_dev_server();
     1255#endif
     1256#if defined(SH_WITH_CLIENT) || defined(SH_STANDALONE)
     1257  sh_restrict_purge ();
     1258 
     1259 
     1260  FileSchedOne = free_sched(FileSchedOne);
     1261  FileSchedTwo = free_sched(FileSchedTwo);
     1262 
     1263  for (modnum = 0; modList[modnum].name != NULL; ++modnum)
     1264    {
     1265      /* sh_thread_pause_flag is true, and we block in lock
     1266       * until check has returned, so we are sure check will
     1267       * not run until sh_thread_pause_flag is set to false
     1268       */
     1269      /* if (modList[modnum].initval >= SH_MOD_ACTIVE) */
     1270      (void) modList[modnum].mod_reconf();
     1271    }
     1272#endif
     1273 
     1274  reset_count_dev_console();
     1275  reset_count_dev_time();
     1276 
     1277  (void) sh_unix_maskreset();
     1278 
     1279#ifdef RELOAD_DATABASE
     1280  sh_hash_hashdelete();
     1281
     1282  if (0 != sl_strcmp(file_path('D', 'R'), _("REQ_FROM_SERVER")))
     1283    {
     1284      char hashbuf[KEYBUF_SIZE];
     1285      (void) sl_strlcpy(sh.data.hash,
     1286                        sh_tiger_hash (file_path('D', 'R'),
     1287                                       TIGER_FILE, TIGER_NOLIM,
     1288                                       hashbuf, sizeof(hashbuf)),
     1289                        KEY_LEN+1);
     1290    }
     1291#endif
     1292  (void) sl_trust_purge_user();
     1293  (void) sh_files_hle_reg (NULL);
     1294  (void) sh_prelink_run (NULL, NULL, 0, 0);
     1295 
     1296  /* --------------------------
     1297   * --- READ CONFIGURATION ---
     1298   * --------------------------
     1299   */
     1300  (void) sh_readconf_read ();
     1301  sig_config_read_again = 0;
     1302  (void) sh_files_setrec();
     1303  (void) sh_files_test_setup();
     1304  sh_audit_commit ();
     1305 
     1306  if (0 != sh.flag.nice)
     1307    {
     1308#ifdef HAVE_SETPRIORITY
     1309      setpriority(PRIO_PROCESS, 0, sh.flag.nice);
     1310#else
     1311      nice(sh.flag.nice);
     1312#endif
     1313    }
     1314 
     1315  if (sh.flag.checkSum == SH_CHECK_INIT)
     1316    {
     1317      sh.flag.isdaemon = S_FALSE;
     1318      sh.flag.loop     = S_FALSE;
     1319    }
     1320 
     1321 
     1322  /* --- Initialize modules. ---
     1323   */
     1324  TPT((0, FIL__, __LINE__, _("msg=<Initialize modules.>\n")));
     1325  for (modnum = 0; modList[modnum].name != NULL; ++modnum)
     1326    {
     1327      status = modList[modnum].mod_init(&(modList[modnum]));
     1328     
     1329      if (status < 0)
     1330        {
     1331          if (status == (-1)) {
     1332            sh_error_handle (SH_ERR_NOTICE, FIL__, __LINE__,
     1333                             status, MSG_MOD_FAIL,
     1334                             _(modList[modnum].name),
     1335                             status+SH_MOD_OFFSET);
     1336          } else {
     1337            sh_error_handle ((-1), FIL__, __LINE__,
     1338                             status, MSG_MOD_FAIL,
     1339                             _(modList[modnum].name),
     1340                             status+SH_MOD_OFFSET);
     1341          }
     1342          modList[modnum].initval = SH_MOD_FAILED;
     1343        }
     1344      else
     1345        {
     1346          sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_MOD_OK,
     1347                           _(modList[modnum].name));
     1348          modList[modnum].initval = status;
     1349        }
     1350    }
     1351 
     1352  /* module is properly set up now
     1353   */
     1354  sh_thread_pause_flag = S_FALSE;
     1355
     1356  return;
     1357}
     1358
     1359static void check_signals (volatile int *flag_check_1,
     1360                           volatile int * flag_check_2)
     1361{
     1362  if (sig_raised > 0)
     1363    {
     1364     
     1365      TPT((0, FIL__, __LINE__, _("msg=<Process a signal.>\n")))
     1366       
     1367        if (sig_termfast == 1)  /* SIGTERM */
     1368          {
     1369            TPT((0, FIL__, __LINE__, _("msg=<Terminate.>\n")));
     1370            --sig_raised; --sig_urgent;
     1371            aud_exit (FIL__, __LINE__, EXIT_SUCCESS);
     1372          }
     1373     
     1374      if (sig_force_check == 1) /* SIGTTOU */
     1375        {
     1376          TPT((0, FIL__, __LINE__, _("msg=<Check run triggered.>\n")));
     1377          *flag_check_1 = 1; *flag_check_2 = 1;
     1378          sig_force_check = 0; --sig_raised;
     1379          sh_sem_trylock();
     1380        }
     1381     
     1382      if (sig_config_read_again == 1 && /* SIGHUP */
     1383          sh_global_suspend_flag == 0)
     1384        {
     1385          TPT((0, FIL__, __LINE__, _("msg=<Re-read configuration.>\n")));
     1386          do_reconf();
     1387          --sig_raised;
     1388        }
     1389     
     1390      if (sig_fresh_trail == 1) /* SIGIOT */
     1391        {
     1392          if (sh_global_suspend_flag == 0)
     1393            {
     1394              SH_MUTEX_LOCK(mutex_thread_nolog);
     1395             
     1396              /* Logfile access
     1397               */
     1398#ifdef SH_USE_XML
     1399              (void) sh_log_file (NULL, NULL);
     1400#endif
     1401              TPT((0, FIL__, __LINE__, _("msg=<Logfile stop/restart.>\n")));
     1402              sh_error_only_stderr (S_TRUE);
     1403              (void) sh_unix_rm_lock_file(sh.srvlog.name);
     1404              (void) retry_msleep(3, 0);
     1405              sh.flag.log_start = S_TRUE;
     1406              sh_error_only_stderr (S_FALSE);
     1407              sh_thread_pause_flag = S_FALSE;
     1408              sig_fresh_trail       = 0;
     1409              --sig_raised;
     1410              SH_MUTEX_UNLOCK(mutex_thread_nolog);
     1411            }
     1412        }
     1413     
     1414      if (sig_terminate == 1)  /* SIGQUIT */
     1415        {
     1416          TPT((0, FIL__, __LINE__, _("msg=<Terminate.>\n")));
     1417          strncpy (sh_sig_msg, _("Quit"), 20);
     1418          --sig_raised;
     1419          aud_exit (FIL__, __LINE__, EXIT_SUCCESS);
     1420        }
     1421         
     1422      if (sig_debug_switch == 1)  /* SIGUSR1 */
     1423        {
     1424          TPT((0, FIL__, __LINE__, _("msg=<Debug switch.>\n")));
     1425          sh_error_dbg_switch();
     1426          sig_debug_switch = 0;
     1427          --sig_raised;
     1428        }
     1429         
     1430      if (sig_suspend_switch > 0)  /* SIGUSR2 */
     1431        {
     1432          TPT((0, FIL__, __LINE__, _("msg=<Suspend switch.>\n")));
     1433          if (sh_global_suspend_flag != 1) {
     1434            SH_MUTEX_LOCK_UNSAFE(mutex_thread_nolog);
     1435            sh_global_suspend_flag = 1;
     1436            sh_error_handle((-1), FIL__, __LINE__, 0, MSG_SUSPEND,
     1437                            sh.prg_name);
     1438          } else {
     1439            sh_global_suspend_flag = 0;
     1440            SH_MUTEX_UNLOCK_UNSAFE(mutex_thread_nolog);
     1441          }
     1442          --sig_suspend_switch;
     1443          --sig_raised; --sig_urgent;
     1444        }
     1445
     1446      if (sh_load_delta_flag > 0 &&
     1447          sh_global_suspend_flag == 0)  /* DELTA Command */
     1448        {
     1449          if (0 == sh_dbIO_load_delta())
     1450            {
     1451              --sh_load_delta_flag; --sig_raised;
     1452            }
     1453        }
     1454
     1455      sig_raised = (sig_raised < 0) ? 0 : sig_raised;
     1456      sig_urgent = (sig_urgent < 0) ? 0 : sig_urgent;
     1457      TPT((0, FIL__, __LINE__, _("msg=<End signal processing.>\n")));
     1458    }
     1459  return;
     1460}
     1461
     1462void check_for_delta_db()
     1463{
     1464  /* Need to contact the server.
     1465   */
     1466  sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_CHECK_2);
     1467
     1468  if (sig_raised > 0 && sh_load_delta_flag > 0)  /* DELTA Command */
     1469    {
     1470      /* There was a DELTA Command
     1471       */
     1472      if (0 == sh_dbIO_load_delta())
     1473        {
     1474          --sh_load_delta_flag; --sig_raised;
     1475        }
     1476    }
     1477  return;
     1478}
     1479
    12171480#endif
    12181481
    … …  
    12291492{
    12301493#if defined(INET_SYSLOG)
    1231   extern int    create_syslog_socket (int flag);
     1494  extern int    sh_xfer_create_syslog_socket (int flag);
    12321495#endif
    12331496#if defined(SH_WITH_SERVER)
    … …  
    12721535  /* --- Close all but first three file descriptors. ---
    12731536   */
    1274   sh_unix_closeall(3, -1, SL_FALSE); /* at program start */
     1537  sh_unix_closeall(3, -1, S_FALSE); /* at program start */
    12751538
    12761539
    … …  
    15351798  /* --- load database; checksum of database
    15361799   */
    1537 #if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
    1538   TPT((0, FIL__, __LINE__, _("msg=<Get checksum of the database.>\n")))
    1539   if (sh.flag.checkSum == SH_CHECK_CHECK)
    1540     {
    1541       if (0 != sl_strcmp(file_path('D', 'R'), _("REQ_FROM_SERVER")))
    1542         {
    1543           char hashbuf[KEYBUF_SIZE];
    1544           (void) sl_strlcpy(sh.data.hash,
    1545                             sh_tiger_hash (file_path('D', 'R'),
    1546                                            TIGER_FILE, TIGER_NOLIM,
    1547                                            hashbuf, sizeof(hashbuf)),
    1548                             KEY_LEN+1);
    1549         }
    1550 
    1551       /* this eventually fetches the file from server to get checksum
    1552        */
    1553       sh_hash_init ();
    1554     }
     1800#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
     1801  if (0 == sh.delayload)
     1802    sh_hash_init_and_checksum();
    15551803#endif
    15561804
    … …  
    15641812    }
    15651813
     1814#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
     1815  if (sh.delayload)
     1816    {
     1817      sleep(sh.delayload);
     1818      sh_hash_init_and_checksum();
     1819    }
     1820#endif
     1821
    15661822  /* --- drop privileges eventually ---
    15671823   */
    … …  
    15691825  sh_create_tcp_socket ();
    15701826#if defined(INET_SYSLOG)
    1571   create_syslog_socket (S_TRUE);
     1827  sh_xfer_create_syslog_socket (S_TRUE);
    15721828#endif
    15731829  SL_REQUIRE(sl_policy_get_real(DEFAULT_IDENT) == SL_ENONE,
    … …  
    15911847   */
    15921848#if defined(INET_SYSLOG) && defined(SH_WITH_SERVER)
    1593   create_syslog_socket (S_FALSE);
     1849  sh_xfer_create_syslog_socket (S_FALSE);
    15941850#endif
    15951851
    … …  
    16561912
    16571913 
    1658   if ((skey == NULL) || (skey->mlock_failed == SL_TRUE))
     1914  if ((skey == NULL) || (skey->mlock_failed == S_TRUE))
    16591915    sh_error_handle ((-1), FIL__, __LINE__, EPERM, MSG_MLOCK);
    16601916
    … …  
    16781934  if (sh.flag.isserver == S_TRUE)
    16791935    {
    1680       sh_receive();
     1936      sh_xfer_start_server();
    16811937      TPT((0, FIL__, __LINE__, _("msg=<End server.>\n")))
    16821938      aud_exit (FIL__, __LINE__, EXIT_SUCCESS);
    16831939    }
    16841940#else
    1685   sh_receive();
     1941  sh_xfer_start_server();
    16861942  TPT((0, FIL__, __LINE__, _("msg=<End server.>\n")))
    16871943  aud_exit (FIL__, __LINE__, EXIT_SUCCESS);
    … …  
    17452001    }
    17462002
     2003  /*  --------  CREATE SEMAPHORE  ---------
     2004   */
     2005  sh_sem_open();
     2006
    17472007  /*  --------  MAIN LOOP  ---------
    17482008   */
    … …  
    17632023      tcurrent = time (NULL);
    17642024
    1765       if (sig_raised > 0)
    1766         {
    1767 
    1768           TPT((0, FIL__, __LINE__, _("msg=<Process a signal.>\n")))
    1769 
    1770           if (sig_termfast == 1)  /* SIGTERM */
    1771             {
    1772               TPT((0, FIL__, __LINE__, _("msg=<Terminate.>\n")));
    1773               /* strncpy (sh_sig_msg, _("SIGTERM"), 20); */
    1774               --sig_raised; --sig_urgent;
    1775               aud_exit (FIL__, __LINE__, EXIT_SUCCESS);
    1776             }
    1777 
    1778           if (sig_force_check == 1) /* SIGTTOU */
    1779             {
    1780               TPT((0, FIL__, __LINE__, _("msg=<Check run triggered.>\n")));
    1781               flag_check_1 = 1;
    1782               flag_check_2 = 1;
    1783               sig_force_check = 0;
    1784               --sig_raised;
    1785             }
    1786          
    1787           if (sig_config_read_again == 1 && /* SIGHUP */
    1788               sh_global_suspend_flag == 0)
    1789             {
    1790               TPT((0, FIL__, __LINE__, _("msg=<Re-read configuration.>\n")))
    1791               sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_RECONF);
    1792 
    1793               sh_thread_pause_flag = S_TRUE;
    1794 
    1795 #if defined(WITH_EXTERNAL)
    1796               /* delete list of external tasks
    1797                */
    1798               (void) sh_ext_cleanup();
    1799 #endif
    1800 #if defined(SH_WITH_MAIL)
    1801               sh_nmail_free();
    1802 #endif
    1803 
    1804               /* delete the file list, make all database
    1805                * entries visible (allignore = FALSE)
    1806                */
    1807               (void) sh_files_deldirstack ();
    1808               (void) sh_files_delfilestack ();
    1809               (void) sh_files_delglobstack ();
    1810               (void) sh_ignore_clean ();
    1811               (void) hash_full_tree ();
    1812               sh_audit_delete_all ();
    1813 
    1814 
    1815 #if defined(SH_WITH_CLIENT)
    1816               reset_count_dev_server();
    1817 #endif
    1818 #if defined(SH_WITH_CLIENT) || defined(SH_STANDALONE)
    1819               sh_restrict_purge ();
    1820 
    1821 
    1822               FileSchedOne = free_sched(FileSchedOne);
    1823               FileSchedTwo = free_sched(FileSchedTwo);
    1824 
    1825               for (modnum = 0; modList[modnum].name != NULL; ++modnum)
    1826                 {
    1827                   /* sh_thread_pause_flag is true, and we block in lock
    1828                    * until check has returned, so we are sure check will
    1829                    * not run until sh_thread_pause_flag is set to false
    1830                    */
    1831                   /* if (modList[modnum].initval >= SH_MOD_ACTIVE) */
    1832                   (void) modList[modnum].mod_reconf();
    1833                 }
    1834 #endif
    1835 
    1836               reset_count_dev_console();
    1837               reset_count_dev_time();
    1838 
    1839               (void) sh_unix_maskreset();
    1840  
    1841               /* Should this be included ???
    1842                * (i.e. should we reload the database ?)
    1843                */
    1844 #ifdef RELOAD_DATABASE
    1845               sh_hash_hashdelete();
    1846 
    1847               if (0 != sl_strcmp(file_path('D', 'R'), _("REQ_FROM_SERVER")))
    1848                 {
    1849                   char hashbuf[KEYBUF_SIZE];
    1850                   (void) sl_strlcpy(sh.data.hash,
    1851                                     sh_tiger_hash (file_path('D', 'R'),
    1852                                                    TIGER_FILE, TIGER_NOLIM,
    1853                                                    hashbuf, sizeof(hashbuf)),
    1854                                     KEY_LEN+1);
    1855                 }
    1856 #endif
    1857               (void) sl_trust_purge_user();
    1858               (void) sh_files_hle_reg (NULL);
    1859               (void) sh_prelink_run (NULL, NULL, 0);
    1860 
    1861               /* --------------------------
    1862                * --- READ CONFIGURATION ---
    1863                * --------------------------
    1864                */
    1865               (void) sh_readconf_read ();
    1866               sig_config_read_again = 0;
    1867               (void) sh_files_setrec();
    1868               (void) sh_files_test_setup();
    1869               sh_audit_commit ();
    1870 
    1871               if (0 != sh.flag.nice)
    1872                 {
    1873 #ifdef HAVE_SETPRIORITY
    1874                   setpriority(PRIO_PROCESS, 0, sh.flag.nice);
    1875 #else
    1876                   nice(sh.flag.nice);
    1877 #endif
    1878                 }
    1879 
    1880               if (sh.flag.checkSum == SH_CHECK_INIT)
    1881                 {
    1882                   sh.flag.isdaemon = S_FALSE;
    1883                   sh.flag.loop     = S_FALSE;
    1884                 }
    1885 
    1886 
    1887               /* --- Initialize modules. ---
    1888                */
    1889               TPT((0, FIL__, __LINE__, _("msg=<Initialize modules.>\n")));
    1890               for (modnum = 0; modList[modnum].name != NULL; ++modnum)
    1891                 {
    1892                   status = modList[modnum].mod_init(&(modList[modnum]));
    1893 
    1894                   if (status < 0)
    1895                     {
    1896                       if (status == (-1)) {
    1897                         sh_error_handle (SH_ERR_NOTICE, FIL__, __LINE__,
    1898                                          status, MSG_MOD_FAIL,
    1899                                          _(modList[modnum].name),
    1900                                          status+SH_MOD_OFFSET);
    1901                       } else {
    1902                         sh_error_handle ((-1), FIL__, __LINE__,
    1903                                          status, MSG_MOD_FAIL,
    1904                                          _(modList[modnum].name),
    1905                                          status+SH_MOD_OFFSET);
    1906                       }
    1907                       modList[modnum].initval = SH_MOD_FAILED;
    1908                     }
    1909                   else
    1910                     {
    1911                       sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_MOD_OK,
    1912                                        _(modList[modnum].name));
    1913                       modList[modnum].initval = status;
    1914                     }
    1915                 }
    1916 
    1917               /* module is properly set up now
    1918                */
    1919               sh_thread_pause_flag = S_FALSE;
    1920              
    1921               --sig_raised;
    1922             }
    1923          
    1924           if (sig_fresh_trail == 1) /* SIGIOT */
    1925             {
    1926               if (sh_global_suspend_flag == 0)
    1927                 {
    1928                   SH_MUTEX_LOCK(mutex_thread_nolog);
    1929 
    1930                   /* Logfile access
    1931                    */
    1932 #ifdef SH_USE_XML
    1933                   (void) sh_log_file (NULL, NULL);
    1934 #endif
    1935                   TPT((0, FIL__, __LINE__, _("msg=<Logfile stop/restart.>\n")));
    1936                   sh_error_only_stderr (S_TRUE);
    1937                   (void) sh_unix_rm_lock_file(sh.srvlog.name);
    1938                   (void) retry_msleep(3, 0);
    1939                   sh.flag.log_start = S_TRUE;
    1940                   sh_error_only_stderr (S_FALSE);
    1941                   sh_thread_pause_flag = S_FALSE;
    1942                   sig_fresh_trail       = 0;
    1943                   --sig_raised;
    1944                   SH_MUTEX_UNLOCK(mutex_thread_nolog);
    1945                 }
    1946             }
    1947          
    1948           if (sig_terminate == 1)  /* SIGQUIT */
    1949             {
    1950               TPT((0, FIL__, __LINE__, _("msg=<Terminate.>\n")));
    1951               strncpy (sh_sig_msg, _("Quit"), 20);
    1952               --sig_raised; --sig_urgent;
    1953               aud_exit (FIL__, __LINE__, EXIT_SUCCESS);
    1954             }
    1955          
    1956           if (sig_debug_switch == 1)  /* SIGUSR1 */
    1957             {
    1958               TPT((0, FIL__, __LINE__, _("msg=<Debug switch.>\n")));
    1959               sh_error_dbg_switch();
    1960               sig_debug_switch = 0;
    1961               --sig_raised;
    1962             }
    1963          
    1964           if (sig_suspend_switch > 0)  /* SIGUSR2 */
    1965             {
    1966               TPT((0, FIL__, __LINE__, _("msg=<Suspend switch.>\n")));
    1967               if (sh_global_suspend_flag != 1) {
    1968                 SH_MUTEX_LOCK_UNSAFE(mutex_thread_nolog);
    1969                 sh_global_suspend_flag = 1;
    1970                 sh_error_handle((-1), FIL__, __LINE__, 0, MSG_SUSPEND,
    1971                                 sh.prg_name);
    1972               } else {
    1973                 sh_global_suspend_flag = 0;
    1974                 SH_MUTEX_UNLOCK_UNSAFE(mutex_thread_nolog);
    1975               }
    1976               --sig_suspend_switch;
    1977               --sig_raised; --sig_urgent;
    1978             }
    1979           sig_raised = (sig_raised < 0) ? 0 : sig_raised;
    1980           sig_urgent = (sig_urgent < 0) ? 0 : sig_urgent;
    1981           TPT((0, FIL__, __LINE__, _("msg=<End signal processing.>\n")));
    1982         }
    1983      
    1984       if (sh_global_suspend_flag == 1)
    1985         {
     2025      do {
     2026        check_signals(&flag_check_1, &flag_check_2);
     2027        if (sh_global_suspend_flag == 1)
    19862028          (void) retry_msleep (1, 0);
    1987           continue;
    1988         }
     2029      } while (sh_global_suspend_flag == 1);
    19892030     
    19902031      /* see whether its time to check files
    … …  
    20262067          (flag_check_1 == 1 || flag_check_2 == 1))
    20272068        {
     2069          sh_sem_trylock();
     2070
     2071          /* Starting a check now, so make sure to fetch delta DB
     2072           * if there is one to download.
     2073           */
     2074          check_for_delta_db();
     2075
    20282076          SH_INOTIFY_IFUSED( sh.flag.inotify |= SH_INOTIFY_INSCAN; );
    20292077          /* Refresh list files matching glob patterns.
    … …  
    20652113            (void) sh_files_chk ();
    20662114
    2067           if (sig_urgent > 0)
    2068             continue;
    2069 
     2115          if (sig_urgent > 0) { sh_sem_unlock(sh.statistics.files_report); continue; }
    20702116          /*
    20712117           * check for files not visited
    … …  
    20772123            }
    20782124
    2079           if (sig_urgent > 0)
    2080             continue;
     2125          if (sig_urgent > 0) { sh_sem_unlock(sh.statistics.files_report); continue; }
    20812126
    20822127          /* reset
    … …  
    20842129          TPT((0, FIL__, __LINE__, _("msg=<Reset status.>\n")))
    20852130          sh_dirs_reset  ();
    2086           if (sig_urgent > 0)
    2087             continue;
     2131
     2132          if (sig_urgent > 0) { sh_sem_unlock(sh.statistics.files_report); continue; }
    20882133
    20892134          sh_files_reset ();
     2135          check_done   = 1;
     2136
    20902137          flag_check_1 = 0;
    20912138          flag_check_2 = 0;
    2092           check_done   = 1;
     2139          sh_sem_unlock(sh.statistics.files_report);
     2140
    20932141          SH_INOTIFY_IFUSED( sh.flag.inotify &= ~SH_INOTIFY_INSCAN; );
    20942142          SH_INOTIFY_IFUSED( sh.flag.inotify &= ~SH_INOTIFY_DOSCAN; );
    20952143
    2096           (void) sh_prelink_run (NULL, NULL, 0);
    2097 
    2098           if (sig_urgent > 0)
    2099             continue;
     2144          (void) sh_prelink_run (NULL, NULL, 0, 0);
     2145
     2146          if (sig_urgent > 0) continue;
    21002147
    21012148          runtim = time(NULL) - sh.statistics.time_start;
    … …  
    21302177          sh.fileCheck.alarm_last = time (NULL);
    21312178
    2132           if (sig_urgent > 0)
    2133             continue;
     2179          if (sig_urgent > 0) continue;
    21342180
    21352181          /*
    … …  
    21422188        }
    21432189     
    2144       if (sig_urgent > 0)
    2145         continue;
     2190      if (sig_urgent > 0) continue;
    21462191     
    21472192      /* execute modules
    … …  
    21612206       */
    21622207      if      (sh.flag.checkSum == SH_CHECK_INIT)
    2163         sh_hash_pushdata (NULL, NULL);
     2208        sh_dbIO_data_write (NULL, NULL);
    21642209
    21652210      /* write out database
    … …  
    21682213          sh.flag.update == S_TRUE &&
    21692214          check_done == 1)
    2170         sh_hash_writeout ();
     2215        sh_dbIO_writeout_update ();
    21712216
    21722217      /* no-op unless MEM_LOG is defined in sh_mem.c
    … …  
    21962241      /* no loop if not daemon
    21972242       */
    2198       if (sh.flag.isdaemon != S_TRUE && sh.flag.loop == S_FALSE)
    2199         break;
    2200       if (sig_urgent > 0)
    2201         continue;
     2243      if (sh.flag.isdaemon != S_TRUE && sh.flag.loop == S_FALSE) break;
     2244      if (sig_urgent > 0) continue;
    22022245
    22032246      /* see whether its time to send mail
    … …  
    22112254        }
    22122255#endif
    2213       if (sig_urgent > 0)
    2214         continue;
     2256      if (sig_urgent > 0) continue;
    22152257           
    22162258      /* log the timestamp
    … …  
    22322274      (void) taus_seed();
    22332275     
    2234       if (sig_urgent > 0)
    2235         continue;
     2276      if (sig_urgent > 0) continue;
    22362277     
    22372278      /* reset cache
    … …  
    22662307#endif
    22672308
    2268 #if 0
    2269   {
    2270     char command[128];
    2271     sprintf(command, "/bin/cat /proc/%d/status", (int) getpid());
    2272     system(command); /* flawfinder: ignore *//* debug code */
    2273     malloc_stats();
    2274   }
    2275 #endif
    2276 
    22772309  aud_exit (FIL__, __LINE__, EXIT_SUCCESS);
    22782310  SL_RETURN(0, _("main"));

  • trunk/src/sh_calls.c

    r473 r481  
    262262  errno = error;
    263263
    264   if (flag_err_debug == SL_TRUE)
     264  if (flag_err_debug == S_TRUE)
    265265    {
    266266      char ipbuf[SH_IP_BUF];
    … …  
    291291  sh_ipvx_save(serv_addr, ss.ss_family, (struct sockaddr *) &ss);
    292292
    293   if (flag_err_debug == SL_TRUE)
     293  if (flag_err_debug == S_TRUE)
    294294    {
    295295      char ipbuf[SH_IP_BUF];
    … …  
    490490#endif
    491491
    492   SL_ENTER(_("retry_msleep"));
    493 
    494492  errno  = 0;
    495493  if (millisec > 999) millisec = 999;
    … …  
    511509#else
    512510  if (sec > 0)
    513     {
    514       sleep (sec); /* nanosleep not available */
    515     }
    516   else
    517     {
     511    sleep (sec); /* nanosleep not available */
     512  else {
    518513#ifdef HAVE_USLEEP
    519       if (millisec > 0)
    520         {
    521           usleep(1000 * millisec);
    522         }
     514    if (millisec > 0)
     515      usleep(1000 * millisec);
    523516#else
    524       if (millisec > 0)
    525         {
    526           sleep (1);
    527         }
    528 #endif
    529     }
    530 #endif
    531   SL_RETURN(result, _("retry_msleep"));
     517    if (millisec > 0)
     518      sleep (1);
     519#endif
     520  }
     521#endif
     522  return result;
    532523}
    533524
    … …  
    835826 
    836827/*@noreturn@*/
    837 void aud_exit (const char * file, int line, int fd)
     828void aud_exit (const char * file, int line, int exitval)
    838829{
    839830  if (sh.flag.audit != 0 && (sh.flag.aud_mask & AUD_EXIT) != 0)
    840831    sh_error_handle ((-1), file, line, 0, MSG_AUD_EXIT,
    841                       (long) fd);
     832                      (long) exitval);
    842833
    843834  SL_ENTER(_("aud_exit"));
    844835
    845   sh.flag.exit = fd;
    846   exit(fd);
     836  sh.flag.exit = exitval;
     837  exit(exitval);
    847838}
    848839
    849840/*@noreturn@*/
    850 void aud__exit (const char * file, int line, int fd)
     841void aud__exit (const char * file, int line, int exitval)
    851842{
    852843  if (sh.flag.audit != 0 && (sh.flag.aud_mask & AUD_EXIT) != 0)
    853844    sh_error_handle ((-1), file, line, 0, MSG_AUD_EXIT,
    854                       (long) fd);
     845                      (long) exitval);
    855846
    856847  SL_ENTER(_("aud__exit"));
    857848
    858   sh.flag.exit = fd;
    859   _exit(fd);
     849  sh.flag.exit = exitval;
     850  _exit(exitval);
    860851}
    861852

  • trunk/src/sh_cat.c

    r403 r481  
    7070  { MSG_CHECK_0,     SH_ERR_WARN,    RUN,   N_("msg=\"No files or directories defined for checking\"")},
    7171  { MSG_CHECK_1,     SH_ERR_STAMP,   STAMP, N_("msg=\"File check completed.\" time=\"%ld\" kBps=\"%f\"")},
     72  { MSG_CHECK_2,     SH_ERR_STAMP,   STAMP, N_("msg=\"File check starting.\"")},
    7273  { MSG_STAMP,       SH_ERR_STAMP,   STAMP, N_("msg=\"---- TIMESTAMP ----\"")},
    7374
    … …  
    7576  { MSG_D_DSTART,    SH_ERR_INFO,    RUN,   N_("msg=\"Downloading database file\"")},
    7677  { MSG_D_FAIL,      SH_ERR_INFO,    RUN,   N_("msg=\"No file from server, trying local file\"")},
     78  { MSG_D_DELTAOK,   SH_ERR_SEVERE,  RUN,   N_("msg=\"Delta database downloaded\", path=\"%s\"")},
     79  { MSG_D_DELTAFAIL, SH_ERR_SEVERE,  RUN,   N_("msg=\"Delta database download failed\", path=\"%s\"")},
    7780
    7881
    … …  
    9396  { MSG_SUID_QREPORT,SH_ERR_SEVERE,  EVENT, N_("msg=\"Quarantine report: %s\" path=\"%s\"") },
    9497  { MSG_SUID_ERROR,  SH_ERR_SEVERE,  EVENT, N_("msg=\"Quarantine error: %s\"") },
    95 #endif
    96 
    97 #ifdef SH_USE_KERN
    98   /* FreeBSD */
    99   { MSG_KERN_POLICY, SH_ERR_SEVERE,  EVENT, N_("msg=\"POLICY [Kernel] BSD syscall table: new: %#lx old: %#lx\" syscall=\"%03d %s\"") },
    100   { MSG_KERN_POL_CO, SH_ERR_SEVERE,  EVENT, N_("msg=\"POLICY [Kernel] BSD syscall code: new: %#x,%#x old: %#x,%#x\" syscall=\"%03d %s\"") },
    101 
    102   /* Linux */
    103   { MSG_KERN_SYSCALL,SH_ERR_SEVERE,  EVENT, N_("msg=\"POLICY [Kernel] SYSCALL modified syscall\" syscall=\"%03d %s\" %s") },
    104   { MSG_KERN_PROC,   SH_ERR_SEVERE,  EVENT, N_("msg=\"POLICY [Kernel] PROC modified proc filesystem: %s\"") },
    105   { MSG_KERN_IDT,    SH_ERR_SEVERE,  EVENT, N_("msg=\"POLICY [Kernel] IDT modified interrupt %03d: new: 0x%-8.8lx %-9s %3d %c old: 0x%-8.8lx %-9s %3d %c\" %s") },
    106   { MSG_KERN_GATE,   SH_ERR_SEVERE,  EVENT, N_("msg=\"POLICY [Kernel] SYS_GATE modified system_call: new: %#x,%#x old: %#x,%#x\" syscall=\"%03d %s\" %s") },
    107 
    10898#endif
    10999
    … …  
    411401  { MSG_CHECK_0,     SH_ERR_WARN,    RUN,   N_("msg=<No files or directories defined for checking>")},
    412402  { MSG_CHECK_1,     SH_ERR_STAMP,   STAMP, N_("msg=<File check completed.>, time=<%ld>, kBps=<%f>")},
     403  { MSG_CHECK_2,     SH_ERR_STAMP,   STAMP, N_("msg=<File check starting.>")},
    413404  { MSG_STAMP,       SH_ERR_STAMP,   STAMP, N_("msg=<---- TIMESTAMP ---->")},
    414405
    … …  
    416407  { MSG_D_DSTART,    SH_ERR_INFO,    RUN,   N_("msg=<Downloading database file>")},
    417408  { MSG_D_FAIL,      SH_ERR_INFO,    RUN,   N_("msg=<No file from server, trying local file>")},
     409  { MSG_D_DELTAOK,   SH_ERR_SEVERE,  RUN,   N_("msg=<Delta database downloaded>, path=<%s>")},
     410  { MSG_D_DELTAFAIL, SH_ERR_SEVERE,  RUN,   N_("msg=<Delta database download failed>, path=<%s>")},
    418411
    419412

  • trunk/src/sh_database.c

    r454 r481  
    180180  { NULL, N_("link_old"),    0,  49, MAX_PATH_STORE+1, 0, offsetof(struct dbins_, link_old)},
    181181  { NULL, N_("link_new"),    0,  50, MAX_PATH_STORE+1, 0, offsetof(struct dbins_, link_new)},
    182                                            
     182
     183  /* These go into  dbins.ulong_data[n - START_SEC_LONGS] */                                               
    183184  { NULL, N_("size_old"),     0,  51,    0, 0, 0  },
    184185  { NULL, N_("size_new"),     0,  52,    0, 0, 0  },
    … …  
    201202  { NULL, N_("port"),         0,  67,    0, 0, 0  },
    202203  { NULL, N_("return_code"),  0,  68,    0, 0, 0  },
    203   /* { NULL, N_("userid"),        0,  69,    0, 0  }, old 'userid', 1.8.1 */
    204 
    205   { NULL, N_("host"),         0,  70,   64, 0, offsetof(struct dbins_, fromhost)},
    206   { NULL, N_("attr_old"),     0,  71,   16, 0, offsetof(struct dbins_, attr_old)},
    207   { NULL, N_("attr_new"),     0,  72,   16, 0, offsetof(struct dbins_, attr_new)},
    208   { NULL, N_("acl_old"),      0,  73, 1024, 0, offsetof(struct dbins_, acl_old)},
    209   { NULL, N_("acl_new"),      0,  74, 1024, 0, offsetof(struct dbins_, acl_new)},
     204
     205  { NULL, N_("checkflags_old"), 0,  69,    0, 0, 0  },
     206  { NULL, N_("checkflags_new"), 0,  70,    0, 0, 0  },
     207
     208  /* END_SEC_LONGS                                         */
     209
     210  { NULL, N_("host"),         0,  71,   64, 0, offsetof(struct dbins_, fromhost)},
     211  { NULL, N_("attr_old"),     0,  72,   16, 0, offsetof(struct dbins_, attr_old)},
     212  { NULL, N_("attr_new"),     0,  73,   16, 0, offsetof(struct dbins_, attr_new)},
     213  { NULL, N_("acl_old"),      0,  74, 1024, 0, offsetof(struct dbins_, acl_old)},
     214  { NULL, N_("acl_new"),      0,  75, 1024, 0, offsetof(struct dbins_, acl_new)},
    210215
    211216  { NULL, NULL,      0,  0, 0, 0, 0 }
    212217};
    213218
    214 #define SH_SLOT_HOST    70
     219#define SH_SLOT_CHECKFLAGS 69
     220
     221/* need special attention b/o reserved SQL words    */
     222#define SH_SLOT_HOST    71
    215223#define SH_SLOT_GROUP    7
     224
     225/* these go into dbins.ulong_data[n-START_SEC_LONGS */
    216226#define START_SEC_LONGS 51
    217 #define END_SEC_LONGS   68
     227#define END_SEC_LONGS   70
    218228
    219229#if defined(HAVE_INT_32)
    … …  
    11631173    }
    11641174
    1165   if (flag_err_debug == SL_TRUE)
     1175  if (flag_err_debug == S_TRUE)
    11661176    {
    11671177      p = mysql_info (db_conn);
    … …  
    13601370  while (attr_tab[i].attr != NULL)
    13611371    {
     1372      if (SH_SLOT_CHECKFLAGS == attr_tab[i].val) {
     1373        if (db_entry->ulong_data[attr_tab[i].val-START_SEC_LONGS] == 0 &&
     1374            db_entry->ulong_data[attr_tab[i+1].val-START_SEC_LONGS] == 0)
     1375          { i+= 2; continue; }
     1376      }
     1377
    13621378      if (attr_tab[i].size != 0)
    13631379        {
    … …  
    17281744                                       (size_t) res->size);
    17291745                  }
    1730                 else if (res->val >= START_SEC_LONGS)
     1746                else if (res->val >= START_SEC_LONGS && res->val <= END_SEC_LONGS)
    17311747                  {
    17321748                    db_entry->ulong_data[res->val-START_SEC_LONGS]
    1733                       = strtoul(&p[j+2], (char **) NULL, 10);
    1734                     /* atol(&p[j+2]); */
     1749                      = strtoul(&p[j+2], (char **) NULL, 0);
    17351750                  }
    17361751

  • trunk/src/sh_entropy.c

    r473 r481  
    300300        {
    301301          m_count = sl_read_timeout_fd(fd2, nbuf, nbytes,
    302                                        timeout_val, SL_FALSE);
     302                                       timeout_val, S_FALSE);
    303303          if (m_count < 0)
    304304            m_count = 0;
    … …  
    337337
    338338#ifdef NAME_OF_DEV_URANDOM
    339   m_count = read_mbytes (  1, NAME_OF_DEV_RANDOM, nbuf, nbytes);
     339  m_count = read_mbytes ( 10, NAME_OF_DEV_URANDOM, nbuf, nbytes);
    340340#else
    341   m_count = read_mbytes (300, NAME_OF_DEV_RANDOM, nbuf, nbytes);
     341  m_count = read_mbytes (300, NAME_OF_DEV_RANDOM,  nbuf, nbytes);
    342342#endif
    343343
    … …  
    346346#ifdef NAME_OF_DEV_URANDOM
    347347      sh_error_handle (SH_ERR_NOTICE, FIL__, __LINE__, EIO, MSG_NODEV,
    348                        (long) sh.real.uid, NAME_OF_DEV_RANDOM);
     348                       (long) sh.real.uid, NAME_OF_DEV_URANDOM);
    349349#else
    350350      sh_error_handle ((-1), FIL__, __LINE__, EIO, MSG_NODEV,
    … …  
    353353    }
    354354
    355 #ifdef NAME_OF_DEV_URANDOM
     355#ifdef NAME_OF_DEV_RANDOM
    356356  if (m_count < nbytes)
    357357    {
    358       i = read_mbytes(30, NAME_OF_DEV_URANDOM, &nbuf[m_count], nbytes-m_count);
     358      i = read_mbytes(300, NAME_OF_DEV_RANDOM, &nbuf[m_count], nbytes-m_count);
    359359      if (i == 0)
    360360        sh_error_handle ((-1), FIL__, __LINE__, EIO, MSG_NODEV,
    361                          (long) sh.real.uid, NAME_OF_DEV_URANDOM);
     361                         (long) sh.real.uid, NAME_OF_DEV_RANDOM);
    362362      else
    363363        m_count += i;
    … …  
    601601      /* don't leak file descriptors
    602602       */
    603       sh_unix_closeall (3, -1, SL_TRUE); /* in child process */
     603      sh_unix_closeall (3, -1, S_TRUE); /* in child process */
    604604
    605605      /* zero priv info
    … …  
    942942    }
    943943
     944#ifdef HAVE_GETTIMEOFDAY
     945  {
     946    unsigned short tseed[3];
     947
     948    gettimeofday(&tv, 0);
     949    tseed[0] = tv.tv_sec & 0xFFFF;
     950    tseed[1] = tv.tv_usec & 0xFFFF;
     951    tseed[2] = (tv.tv_sec ^ tv.tv_usec) >> 16;
     952    keybuf = (char *) sh_tiger_hash_uint32 ((char *) tseed,
     953                                            TIGER_DATA, sizeof(tseed),
     954                                            kbuf, KEY_BYT/sizeof(UINT32));
     955    memset(addbuf, '\0', sizeof(addbuf));
     956    for (i = 0; i < KEY_BYT; ++i)
     957      {
     958        addbuf[i]         = keybuf[i];
     959        addbuf[i+KEY_BYT] = skey->poolv[i];
     960      }
     961    SH_MUTEX_LOCK_UNSAFE(mutex_skey);
     962    for (i = 0; i < KEY_BYT; ++i)
     963      skey->poolv[i] ^= keybuf[i];
     964    SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
     965  }
     966#endif
     967
    944968  if (bufcount > 0)
    945969    {
    … …  
    10021026  char                 bufy[9 * sizeof(UINT32) + 1];
    10031027  int                  status;
    1004 
    1005   memset(skey->poolv, '\0', KEY_BYT);
    1006 
    1007   status = sh_entropy (24, bufx);
    1008   CuAssertTrue(tc, 0 == status);
    1009 
    1010   memset(skey->poolv, '\0', KEY_BYT);
    1011 
    1012   status = sh_entropy (24, bufy);
    1013   CuAssertTrue(tc, 0 == status);
    1014 
    1015   CuAssertTrue(tc, 0 != memcmp(bufx, bufy, 24));
     1028  int                  count;
     1029
     1030  for (count = 0; count < 20; ++count)
     1031    {
     1032      memset(skey->poolv, '\0', KEY_BYT);
     1033      skey->poolc = 0;
     1034
     1035      status = sh_entropy (24, bufx);
     1036      CuAssertTrue(tc, 0 == status);
     1037     
     1038      memset(skey->poolv, '\0', KEY_BYT);
     1039      skey->poolc = 0;
     1040
     1041      status = sh_entropy (24, bufy);
     1042      CuAssertTrue(tc, 0 == status);
     1043     
     1044      CuAssertTrue(tc, 0 != memcmp(bufx, bufy, 24));
     1045    }
    10161046}
    10171047#endif

  • trunk/src/sh_err_console.c

    r474 r481  
    2525#include "sh_error.h"
    2626#include "sh_utils.h"
     27#include "sh_sem.h"
    2728
    2829#undef  FIL__
    … …  
    3637
    3738extern int  OnlyStderr;
    38 
    3939 
    4040#if !defined(O_NONBLOCK)
    … …  
    5353#include <sys/msg.h>
    5454
     55#if !defined(EIDRM)
     56#define EIDRM (EINVAL)
     57#endif
     58
    5559struct sh_msgbuf {
    5660  long mtype;
    … …  
    6670/* Open the SysV message queue, creating it when neccesary
    6771 */
    68 static int open_ipc(void)
     72static int open_queue(void)
    6973{
    7074  key_t            key;
    7175#if defined(WITH_TPT)
    72   int              error = 0;
    7376  char errbuf[SH_ERRBUF_SIZE];
    7477#endif
    7578
    76   SL_ENTER(_("open_ipc"));
     79  SL_ENTER(_("open_queue"));
    7780
    7881  /* get key
    7982   */
    80   key = ftok ("/tmp", '#');
     83  key = ftok (DEFAULT_DATAROOT, '#');
     84
    8185  if (key == (key_t) -1)
    8286    {
    83 #if defined(WITH_TPT)
    84       error = errno;
    85 #endif
    8687      TPT(( 0, FIL__, __LINE__, _("msg=<ftok: %s> errno=<%d>\n"),
    87             sh_error_message(error, errbuf, sizeof(errbuf)), error));
    88       SL_RETURN(-1, _("open_ipc"));
     88            sh_error_message(errno, errbuf, sizeof(errbuf)), errno));
     89      SL_RETURN(-1, _("open_queue"));
    8990    }
    9091
    … …  
    9596  if (msgid < 0)
    9697    {
    97 #if defined(WITH_TPT)
    98       error = errno;
    99 #endif
    10098      TPT(( 0, FIL__, __LINE__, _("msg=<msgget: %s> errno=<%d>\n"),
    101             sh_error_message(error, errbuf, sizeof(errbuf)), error));
    102       SL_RETURN(-1, _("open_ipc"));
    103     }
    104 
    105   SL_RETURN(0, _("open_ipc"));
    106 }
    107 
    108 /* Close the SysV message queue
     99            sh_error_message(errno, errbuf, sizeof(errbuf)), errno));
     100      SL_RETURN(-1, _("open_queue"));
     101    }
     102
     103  SL_RETURN(0, _("open_queue"));
     104}
     105
     106/* Close the SysV message queue and/or semaphore
    109107 */
    110108void close_ipc (void)
    111109{
    112   SL_ENTER(_("close_ipc"));
    113 
    114110  if (msgid != (-1))
    115111    (void) msgctl (msgid, IPC_RMID, NULL);
    116   SL_RET0(_("close_ipc"));
     112  sh_sem_close();
     113  return;
    117114}
    118115
    … …  
    128125}
    129126
    130 /* #define MY_MAX_MSG    254 */
    131127#define MY_MAX_MSG    1022
     128
     129static void remove_message()
     130{
     131  int rc;
     132  struct {
     133    long    mtype;       /* Message type. */
     134    char    mtext[128];  /* Message text. */
     135  } recv_msg;
     136
     137  recv_msg.mtype = 1;
     138  do {
     139    rc = msgrcv(msgid, &recv_msg, sizeof(recv_msg.mtext), 1,
     140                MSG_NOERROR|IPC_NOWAIT);
     141  } while (rc < 0 && errno == EINTR);
     142
     143  memset(&recv_msg, '\0', sizeof(recv_msg));
     144  return;
     145}
    132146
    133147static int push_message_queue (const char * msg)
    … …  
    138152  int              count    = 0;
    139153#if defined(WITH_TPT)
    140   int              error = 0;
    141154  char errbuf[SH_ERRBUF_SIZE];
    142155#endif
    … …  
    153166    {
    154167      TPT(( 0, FIL__, __LINE__, _("msg=<msg_queue not open>\n")));
    155       status = open_ipc();
     168      status = open_queue();
    156169    }
    157170
    158171  if (status < 0)
    159172    {
    160       TPT(( 0, FIL__, __LINE__, _("msg=<open_ipc() failed>\n")));
     173      TPT(( 0, FIL__, __LINE__, _("msg=<open_queue() failed>\n")));
    161174      SL_RETURN(-1, _("push_message_queue"));
    162175    }
    … …  
    165178   *   long mtype;
    166179   *   char mtext[1];  <-- sizeof(mtext) will be  1+MY_MAX_MSG
    167    * }
    168    */
     180   * } */
     181
    169182  recv_msg = (struct sh_msgbuf*) SH_ALLOC(sizeof(struct sh_msgbuf)+MY_MAX_MSG);
    170183  recv_msg->mtype = 1;
    … …  
    177190  if (count > 1)
    178191    {
     192      memset(recv_msg, '\0', MY_MAX_MSG+1);
    179193      SH_FREE(recv_msg);
    180194      SL_RETURN(-1, _("push_message_queue"));
    181195    }
    182196
    183   /* send the message
    184    */
    185   do {
    186     errno = 0;
     197  do { errno = 0;
    187198    rc = msgsnd(msgid, recv_msg, strlen(recv_msg->mtext)+1, IPC_NOWAIT);
    188   }
    189   while (rc < 0 && errno == EINTR);
     199
     200    if (rc == -1 && errno == EAGAIN)
     201      remove_message();
     202  } while (rc < 0 && (errno == EINTR && errno == EAGAIN));
    190203 
    191204  if (rc == -1 && errno != EAGAIN)
    192205    {
    193       /* EIDRM is not in OpenBSD
    194        */
    195       if (errno == EINVAL
    196 #if defined(EIDRM)
    197           || errno == EIDRM
    198 #endif
    199           )
    200         {
    201           TPT(( 0, FIL__, __LINE__, _("msg=<msg_queue not open>\n")));
    202           status = open_ipc();
    203           if (status == 0)
    204             {
    205               ++count;
    206               goto send_it;
    207             }
    208         }
    209       else
    210         {
    211 #if defined(WITH_TPT)
    212           error = errno;
    213 #endif
    214           TPT(( 0, FIL__, __LINE__, _("msg=<msgsnd: %s> errno=<%d>\n"),
    215                 sh_error_message(error, errbuf, sizeof(errbuf)), error));
    216           SH_FREE(recv_msg);
    217           SL_RETURN(-1, _("push_message_queue"));
    218         }
    219     }
    220 
     206      /* EIDRM is not in OpenBSD */
     207      if (errno == EINVAL || errno == EIDRM) {
     208        TPT(( 0, FIL__, __LINE__, _("msg=<msg_queue not open>\n")));
     209        status = open_queue();
     210        if (status == 0) {
     211          ++count;
     212          goto send_it; }
     213      } else {
     214        TPT(( 0, FIL__, __LINE__, _("msg=<msgsnd: %s> errno=<%d>\n"),
     215              sh_error_message(errno, errbuf, sizeof(errbuf)), errno));
     216        memset(recv_msg, '\0', MY_MAX_MSG+1);
     217        SH_FREE(recv_msg);
     218        SL_RETURN(-1, _("push_message_queue"));
     219      }
     220    }
     221
     222  memset(recv_msg, '\0', MY_MAX_MSG+1);
    221223  SH_FREE(recv_msg);
     224
    222225  SL_RETURN(0, _("push_message_queue"));
    223226}
    … …  
    234237#endif
    235238
     239#else /* no message queue */
     240
     241void close_ipc() { sh_sem_close(); return; }
     242
    236243#endif
    237244
    … …  
    283290  static int service_failure[2] = { 0, 0};
    284291  int    fd[2] = { -1, -1};
    285   int    sflags;
    286292  int    cc;
    287293  size_t len;
    … …  
    331337    {
    332338      fd[0] = open ( sh.srvcons.name, O_WRONLY|O_APPEND|O_NOCTTY|O_NONBLOCK);
    333       if (fd[0] >= 0) {
    334         sflags = (int) retry_fcntl(FIL__, __LINE__, fd[0], F_GETFL, 0);
    335         if (sflags >= 0)
    336           {
    337             (void) retry_fcntl(FIL__, __LINE__, fd[0],
    338                                F_SETFL, sflags & ~O_NONBLOCK);
    339           }
    340       }
    341339
    342340      if (sh.srvcons.alt[0] != '\0')
    343341        {
    344342          fd[1] = open (sh.srvcons.alt, O_WRONLY|O_APPEND|O_NOCTTY|O_NONBLOCK);
    345           if (fd[1] >= 0) {
    346             sflags = (int) retry_fcntl(FIL__, __LINE__, fd[1], F_GETFL, 0);
    347             if (sflags >= 0)
    348               {
    349                 (void) retry_fcntl(FIL__, __LINE__, fd[1],
    350                                    F_SETFL, sflags & ~O_NONBLOCK);
    351               }
    352             ccMax = 2;
    353           }
     343          ccMax = 2;
    354344        }
    355345

  • trunk/src/sh_err_log.c

    r459 r481  
    770770
    771771#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
    772   if (skey->mlock_failed == SL_FALSE)
     772  if (skey->mlock_failed == S_FALSE)
    773773    {
    774774      if ( (-1) == sh_unix_mlock( FIL__, __LINE__, log_msg.msg,
    775775                                  (size_t)(2*KEY_LEN + status + 32) ) )
    776776        {
    777           skey->mlock_failed = SL_TRUE;
     777          skey->mlock_failed = S_TRUE;
    778778#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
    779779          sh_error_handle ((-1), FIL__, __LINE__, EPERM, MSG_MLOCK);
    … …  
    782782    }
    783783#else
    784   if (skey->mlock_failed == SL_FALSE)
    785     {
    786       skey->mlock_failed = SL_TRUE;
     784  if (skey->mlock_failed == S_FALSE)
     785    {
     786      skey->mlock_failed = S_TRUE;
    787787#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
    788788      sh_error_handle ((-1), FIL__, __LINE__, EPERM, MSG_MLOCK);
    … …  
    12071207  int i;
    12081208
    1209   if (SL_TRUE == sl_ok_adds (gSave[0], sh.statistics.bytes_hashed))
     1209  if (S_TRUE == sl_ok_adds (gSave[0], sh.statistics.bytes_hashed))
    12101210    gSave[0] += sh.statistics.bytes_hashed;
    1211   if (SL_TRUE == sl_ok_adds (gSave[1], sh.statistics.dirs_checked))
     1211  if (S_TRUE == sl_ok_adds (gSave[1], sh.statistics.dirs_checked))
    12121212    gSave[1] += sh.statistics.dirs_checked;
    1213   if (SL_TRUE == sl_ok_adds (gSave[2], sh.statistics.files_checked))
     1213  if (S_TRUE == sl_ok_adds (gSave[2], sh.statistics.files_checked))
    12141214    gSave[2] += sh.statistics.files_checked;
    1215   if (SL_TRUE == sl_ok_adds (gSave[3], sh.statistics.files_report))
     1215  if (S_TRUE == sl_ok_adds (gSave[3], sh.statistics.files_report))
    12161216    gSave[3] += sh.statistics.files_report;
    1217   if (SL_TRUE == sl_ok_adds (gSave[4], sh.statistics.files_error))
     1217  if (S_TRUE == sl_ok_adds (gSave[4], sh.statistics.files_error))
    12181218    gSave[4] += sh.statistics.files_error;
    1219   if (SL_TRUE == sl_ok_adds (gSave[5], sh.statistics.files_nodir))
     1219  if (S_TRUE == sl_ok_adds (gSave[5], sh.statistics.files_nodir))
    12201220    gSave[5] += sh.statistics.files_nodir;
    12211221

  • trunk/src/sh_error.c

    r476 r481  
    6060#include "sh_tiger.h"
    6161#include "sh_nmail.h"
    62 #include "sh_forward.h"
     62#include "sh_xfer.h"
    6363#include "sh_prelude.h"
    6464#include "sh_pthread.h"
    … …  
    7777extern int clt_class;
    7878
    79 int flag_err_debug = SL_FALSE;
    80 int flag_err_info  = SL_FALSE;
     79int flag_err_debug = S_FALSE;
     80int flag_err_info  = S_FALSE;
    8181
    8282int  ShDFLevel[SH_ERR_T_END];
    … …  
    100100static int  sh_error_init (void);
    101101
    102 /*@owned@*//*@null@*/inline
    103 static char * get_format(unsigned long msg_id, /*@out@*/int * priority,
    104                          /*@out@*/unsigned int * class);
     102inline
     103static const char * get_format(unsigned long msg_id, int * priority,
     104                               unsigned int * class);
    105105
    106106static int sh_error_string (struct _log_t * lmsg, va_list vl);
    … …  
    177177{
    178178  if ((errFlags.loglevel & SH_ERR_ALL) != 0)
    179     flag_err_debug = SL_TRUE;
     179    flag_err_debug = S_TRUE;
    180180  else if ((errFlags.printlevel & SH_ERR_ALL) != 0)
    181     flag_err_debug = SL_TRUE;
     181    flag_err_debug = S_TRUE;
    182182  else if ((errFlags.maillevel & SH_ERR_ALL) != 0)
    183     flag_err_debug = SL_TRUE;
     183    flag_err_debug = S_TRUE;
    184184  else if ((errFlags.exportlevel & SH_ERR_ALL) != 0)
    185     flag_err_debug = SL_TRUE;
     185    flag_err_debug = S_TRUE;
    186186  else if ((errFlags.sysloglevel & SH_ERR_ALL) != 0)
    187     flag_err_debug = SL_TRUE;
     187    flag_err_debug = S_TRUE;
    188188  else if ((errFlags.externallevel & SH_ERR_ALL) != 0)
    189     flag_err_debug = SL_TRUE;
     189    flag_err_debug = S_TRUE;
    190190  else if ((errFlags.databaselevel & SH_ERR_ALL) != 0)
    191     flag_err_debug = SL_TRUE;
     191    flag_err_debug = S_TRUE;
    192192  else if ((errFlags.preludelevel & SH_ERR_ALL) != 0)
    193     flag_err_debug = SL_TRUE;
     193    flag_err_debug = S_TRUE;
    194194  else
    195     flag_err_debug = SL_FALSE;
     195    flag_err_debug = S_FALSE;
    196196  return;
    197197}
    … …  
    201201{
    202202  if ((errFlags.loglevel & SH_ERR_INFO) != 0)
    203     flag_err_info = SL_TRUE;
     203    flag_err_info = S_TRUE;
    204204  else if ((errFlags.printlevel & SH_ERR_INFO) != 0)
    205     flag_err_info = SL_TRUE;
     205    flag_err_info = S_TRUE;
    206206  else if ((errFlags.maillevel & SH_ERR_INFO) != 0)
    207     flag_err_info = SL_TRUE;
     207    flag_err_info = S_TRUE;
    208208  else if ((errFlags.exportlevel & SH_ERR_INFO) != 0)
    209     flag_err_info = SL_TRUE;
     209    flag_err_info = S_TRUE;
    210210  else if ((errFlags.sysloglevel & SH_ERR_INFO) != 0)
    211     flag_err_info = SL_TRUE;
     211    flag_err_info = S_TRUE;
    212212  else if ((errFlags.externallevel & SH_ERR_INFO) != 0)
    213     flag_err_info = SL_TRUE;
     213    flag_err_info = S_TRUE;
    214214  else if ((errFlags.databaselevel & SH_ERR_INFO) != 0)
    215     flag_err_info = SL_TRUE;
     215    flag_err_info = S_TRUE;
    216216  else if ((errFlags.preludelevel & SH_ERR_INFO) != 0)
    217     flag_err_info = SL_TRUE;
     217    flag_err_info = S_TRUE;
    218218  else
    219     flag_err_info = SL_FALSE;
     219    flag_err_info = S_FALSE;
    220220  return;
    221221}
    … …  
    230230                             SH_ERR_SEVERE | SH_ERR_FATAL);
    231231      dbg_flag  = 1;
    232       flag_err_debug = SL_TRUE;
     232      flag_err_debug = S_TRUE;
    233233    }
    234234  else {
    … …  
    935935  int    severity;
    936936  unsigned int class;
    937   char * fmt;
     937  const char * fmt;
    938938  volatile int sev = sev1;            /* Avoids the 'clobbered by longjmp' warning. */
    939939
    … …  
    12861286              sl_snprintf(ex_msg, ex_len, _("%d?%u?%s"),
    12871287                      severity, class, lmsg->msg);
    1288               retval = sh_forward (ex_msg);
     1288              retval = sh_xfer_report (ex_msg);
    12891289              SH_FREE(ex_msg);
    12901290              export_block = 0;
    … …  
    14381438  int    severity;
    14391439  unsigned int class;
    1440   char * fmt;
     1440  const char * fmt;
    14411441  int retval;
    14421442
    … …  
    15171517 */
    15181518/*@owned@*/ /*@null@*/inline
    1519 static char * get_format(unsigned long msg_id, /*@out@*/ int * priority,
     1519static const char * get_format(unsigned long msg_id, /*@out@*/ int * priority,
    15201520                         /*@out@*/unsigned int * class)
    15211521{
    … …  
    15321532          *priority = (int) msg_cat[i].priority;
    15331533          *class    = (unsigned int) msg_cat[i].class;
    1534           SL_RETURN (((char *) _(msg_cat[i].format)), _("get_format"));
     1534          SL_RETURN (((const char *) _(msg_cat[i].format)), _("get_format"));
    15351535        }
    15361536      ++i;
    … …  
    15731573  SL_RETURN( 0, _("sh_error_ehead"));
    15741574}
     1575
     1576#if !defined(VA_COPY)
     1577#if defined(__GNUC__) && defined(__PPC__) && (defined(_CALL_SYSV) || defined(_WIN32))
     1578#define VA_COPY(ap1, ap2)     (*(ap1) = *(ap2))
     1579#elif defined(VA_COPY_AS_ARRAY)
     1580#define VA_COPY(ap1, ap2)     memmove ((ap1), (ap2), sizeof (va_list))
     1581#else /* va_list is a pointer */
     1582#define VA_COPY(ap1, ap2)     ((ap1) = (ap2))
     1583#endif
     1584#endif
    15751585
    15761586
    … …  
    17071717  else
    17081718    {
    1709       /* use va_copy */
    1710       /*@i@*/va_copy(vl2, vl);
     1719      /* use VA_COPY */
     1720      /*@i@*/VA_COPY(vl2, vl);
    17111721      len      = sl_strlen(lmsg->msg);
    17121722      /*@i@*/required = sl_vsnprintf(&(lmsg->msg[len]),
    … …  
    17691779                             SH_ERR_STAMP | SH_ERR_ERR    | SH_ERR_SEVERE |
    17701780                             SH_ERR_FATAL);
    1771   flag_err_info           = SL_TRUE;
     1781  flag_err_info           = S_TRUE;
    17721782#endif
    17731783

  • trunk/src/sh_extern.c

    r440 r481  
    305305           */
    306306#if !defined(PDGBFILE)
    307           sh_unix_closeall (3, task->com_fd, SL_TRUE); /* in child process */
     307          sh_unix_closeall (3, task->com_fd, S_TRUE); /* in child process */
    308308#endif
    309309
    … …  
    423423                char str1[128];
    424424                int ival = pfd;
    425                 int n = 0;
    426                 int m = 0;
     425                unsigned int n = 0;
     426                unsigned int m = 0;
    427427
    428428                if (ival < 0) ival = -ival;
    … …  
    633633            {
    634634              task->exit_status = WEXITSTATUS(task->exit_status);
    635               if ((flag_err_debug == SL_TRUE) || (task->exit_status != 0))
     635              if ((flag_err_debug == S_TRUE) || (task->exit_status != 0))
    636636                sl_snprintf(infomsg, sizeof(infomsg),
    637637                            _("Subprocess exited normally with status %d"),
    … …  
    687687      /*@+bufferoverflowhigh@*/
    688688      status = task->exit_status;
    689       if (flag_err_debug == SL_TRUE)
     689      if (flag_err_debug == S_TRUE)
    690690        {
    691691          sh_error_handle(SH_ERR_ALL, FIL__, __LINE__, task->exit_status,
    … …  
    867867}
    868868
    869 int sh_ext_popen_init (sh_tas_t * task, char * command, char * argv0, ...)
     869int sh_ext_popen_init (sh_tas_t * task, const char * command, char * argv0, ...)
    870870{
    871871  va_list vl;
    … …  
    956956 * ifconfig | grep -1 lo | tail -n 1 | sed s/.*inet addr:\([0-9.]*\)\(.*\)/\1/
    957957 */
    958 char * sh_ext_popen_str (char * command)
     958char * sh_ext_popen_str (const char * command)
    959959{
    960960  sh_tas_t task;

  • trunk/src/sh_fInotify.c

    r433 r481  
    3535#include "sh_unix.h"
    3636#include "sh_hash.h"
     37#include "sh_dbIO.h"
    3738#include "sh_files.h"
    3839#include "sh_ignore.h"
    … …  
    111112static int sh_fInotify_process(struct inotify_event * event);
    112113static int sh_fInotify_report(struct inotify_event * event, char * filename,
    113                               int class, unsigned long check_mask, int ftype, int rdepth);
     114                              int class, unsigned long check_flags, int ftype, int rdepth);
    114115
    115116int sh_fInotify_init(struct mod_type * arg)
    … …  
    236237      count2 = 0; /* Update baseline database. */
    237238      if (sh.flag.checkSum == SH_CHECK_CHECK && sh.flag.update == S_TRUE)
    238         sh_hash_writeout ();
     239        sh_dbIO_writeout_update ();
    239240    }
    240241
    … …  
    329330  int    type;
    330331  int    rdepth;
    331   unsigned long check_mask;
     332  unsigned long check_flags;
    332333  int    retval;
    333334  int    errnum;
    … …  
    349350
    350351  while (NULL != (filename = sh_inotify_pop_dormant(&sh_file_watches,
    351                                                     &class, &check_mask,
     352                                                    &class, &check_flags,
    352353                                                    &type, &rdepth)))
    353354    {
    354355      retval = sh_inotify_add_watch(filename, &sh_file_watches, &errnum,
    355                                     class, check_mask, type, rdepth);
     356                                    class, check_flags, type, rdepth);
    356357
    357358      if (retval < 0)
    … …  
    424425  if (event->mask & IN_UNMOUNT) sl_strlcat(dbgbuf, "IN_UNMOUNT ", sizeof(dbgbuf));
    425426 
    426   /* fprintf(stderr, "FIXME: %s\n", dbgbuf); */
    427  
    428427  SH_MUTEX_LOCK(mutex_thread_nolog);
    429428  sh_error_handle(SH_ERR_ALL, FIL__, __LINE__, 0, MSG_E_SUBGEN,
    … …  
    437436  int ftype;
    438437  int rdepth;
    439   unsigned long check_mask;
     438  unsigned long check_flags;
    440439  char * filename;
    441440  extern int flag_err_debug;
    442441
    443   if (flag_err_debug == SL_TRUE)
     442  if (flag_err_debug == S_TRUE)
    444443    {
    445444      sh_fInotify_logmask(event);
    … …  
    449448    {
    450449      filename = sh_inotify_search_item(&sh_file_watches, event->wd,
    451                                         &class, &check_mask, &ftype, &rdepth);
     450                                        &class, &check_flags, &ftype, &rdepth);
    452451
    453452      if (filename)
    454453        {
    455           sh_fInotify_report(event, filename, class, check_mask, ftype, rdepth);
     454          sh_fInotify_report(event, filename, class, check_flags, ftype, rdepth);
    456455          SH_FREE(filename);
    457456        }
    … …  
    488487}
    489488
    490 void sh_fInotify_report_add(char * path, int class, unsigned long check_mask)
     489void sh_fInotify_report_add(char * path, int class, unsigned long check_flags)
    491490{
    492491  if (S_FALSE == sh_ignore_chk_new(path))
    … …  
    496495      sh_files_clear_file_reported(path);
    497496     
    498       sh_files_search_file(path, &class, &check_mask, &reported);
     497      sh_files_search_file(path, &class, &check_flags, &reported);
    499498     
    500       sh_files_filecheck (class, check_mask, path, NULL,
     499      sh_files_filecheck (class, check_flags, path, NULL,
    501500                          &reported, 0);
    502501      if (SH_FFLAG_REPORTED_SET(reported))
    … …  
    521520static int sh_fInotify_report_change (struct inotify_event * event,
    522521                                      char * path, char * filename,
    523                                       int class, unsigned long check_mask, int ftype)
     522                                      int class, unsigned long check_flags, int ftype)
    524523{
    525524  int    reported;
    … …  
    529528  if (S_FALSE == sh_ignore_chk_mod(path))
    530529    {
    531       ret  = sh_files_search_file(path, &class, &check_mask, &reported);
     530      ret  = sh_files_search_file(path, &class, &check_flags, &reported);
    532531
    533532      if ((ret == 0) && (event->len > 0) && (ftype == SH_INOTIFY_FILE))
    … …  
    537536      else
    538537        {
    539           sh_files_filecheck (class, check_mask, filename,
     538          sh_files_filecheck (class, check_flags, filename,
    540539                              (event->len > 0) ? event->name : NULL,
    541540                              &reported, 0);
    … …  
    548547static int sh_fInotify_report_missing (struct inotify_event * event,
    549548                                       char * path,
    550                                        int class, unsigned long check_mask, int ftype)
     549                                       int class, unsigned long check_flags, int ftype)
    551550{
    552551  int    reported;
    … …  
    560559      if (0 != hashreport_missing(path, level))
    561560        {
    562           int ret = sh_files_search_file(path, &class, &check_mask, &reported);
     561          int ret = sh_files_search_file(path, &class, &check_flags, &reported);
    563562         
    564563          if ((ret == 0) && (event->len > 0) && (ftype == SH_INOTIFY_FILE))
    … …  
    578577    }
    579578
    580 #ifndef REPLACE_OLD
    581   sh_hash_set_visited_true(path);
    582 #else
    583579  sh_hash_set_missing(path);
    584 #endif
     580
    585581  if (sh.flag.reportonce == S_TRUE)
    586582    sh_files_set_file_reported(path);
    … …  
    596592static int sh_fInotify_report_added (struct inotify_event * event,
    597593                                     char * path, char * filename,
    598                                      int class, unsigned long check_mask,
     594                                     int class, unsigned long check_flags,
    599595                                     int ftype, int rdepth)
    600596{
    … …  
    608604      sh_files_clear_file_reported(path);
    609605         
    610       ret = sh_files_search_file(path, &class, &check_mask, &reported);
     606      ret = sh_files_search_file(path, &class, &check_flags, &reported);
    611607     
    612608      if ((ret == 0) && (event->len > 0) && (ftype == SH_INOTIFY_FILE))
    … …  
    618614          int classD = class;
    619615          int reportedD = reported;
    620           unsigned long check_maskD = check_mask;
     616          unsigned long check_flagsD = check_flags;
    621617         
    622618          if (event->mask & IN_ISDIR)
    623619            {
    624               retD = sh_files_search_dir(path, &classD, &check_maskD,
     620              retD = sh_files_search_dir(path, &classD, &check_flagsD,
    625621                                         &reportedD, &rdepthD);
    626622              if (retD != 0)
    … …  
    629625                    {
    630626                      class      = classD;
    631                       check_mask = check_maskD;
     627                      check_flags = check_flagsD;
    632628                    }
    633629                }
    634630            }
    635631         
    636           sh_files_filecheck (class, check_mask, filename,
     632          sh_files_filecheck (class, check_flags, filename,
    637633                              (event->len > 0) ? event->name : NULL,
    638634                              &reported, 0);
    … …  
    641637            {
    642638              SH_INOTIFY_IFUSED( sh.flag.inotify |= SH_INOTIFY_INSCAN;   );
    643               sh_files_checkdir (classD, check_maskD, rdepthD,
     639              sh_files_checkdir (classD, check_flagsD, rdepthD,
    644640                                 path, (event->len > 0) ? event->name : NULL);
    645641              SH_INOTIFY_IFUSED( sh.flag.inotify &= ~SH_INOTIFY_INSCAN;  );
    … …  
    657653        {
    658654          sh_inotify_add_watch(path, &sh_file_watches, &ret,
    659                                class, check_mask,
     655                               class, check_flags,
    660656                               (event->mask & IN_ISDIR)?SH_INOTIFY_DIR:SH_INOTIFY_FILE,
    661657                               rdepthD);
    … …  
    666662
    667663static int sh_fInotify_report(struct inotify_event * event, char * filename,
    668                               int class, unsigned long check_mask, int ftype, int rdepth)
     664                              int class, unsigned long check_flags, int ftype, int rdepth)
    669665{
    670666  char * fullpath = NULL;
    … …  
    684680    {
    685681      sh_fInotify_report_change (event, path, filename,
    686                                  class, check_mask, ftype);
     682                                 class, check_flags, ftype);
    687683    }
    688684  else if ((event->mask & (IN_DELETE|IN_DELETE_SELF|IN_MOVE_SELF|IN_MOVED_FROM)) != 0)
    689685    {
    690686      sh_fInotify_report_missing (event, path,
    691                                   class, check_mask, ftype);
     687                                  class, check_flags, ftype);
    692688   }
    693689  else if((event->mask & (IN_CREATE|IN_MOVED_TO)) != 0)
    694690    {
    695691      sh_fInotify_report_added (event, path, filename,
    696                                 class, check_mask,
     692                                class, check_flags,
    697693                                ftype, rdepth);
    698694    }

  • trunk/src/sh_fifo.c

    r272 r481  
    180180              memset(getit->data, 0, len);
    181181              if (NULL != sl_strstr (getit->data, _("LOGKEY")))
    182                 {
    183                   MUNLOCK(getit->data, (len+1));
    184                   ;
    185                 }
     182                MUNLOCK(getit->data, (len+1));
    186183              if (getit->s_xtra)
    187184                SH_FREE(getit->s_xtra);
    … …  
    197194/* push an item on the head of the list
    198195 */
    199 int push_list (SH_FIFO * fifo, char * indat, int in_i, const char * in_str)
     196int push_list (SH_FIFO * fifo, const char * indat, int in_i, const char * in_str)
    200197{
    201198  struct dlist * item;
    … …  
    224221 
    225222  if (NULL != sl_strstr (indat, _("LOGKEY")))
    226     {
    227       MLOCK(item->data, (len+1));
    228       ;
    229     }
     223    MLOCK(item->data, (len+1));
    230224
    231225  sl_strlcpy (item->data, indat, len+1);
    … …  
    260254/* push an item on the tail of the list
    261255 */
    262 int push_tail_list (SH_FIFO * fifo, char * indat, int in_i, const char * in_str)
     256int push_tail_list (SH_FIFO * fifo, const char * indat, int in_i, const char * in_str)
    263257{
    264258  struct dlist * item;
    … …  
    287281
    288282  if (NULL != sl_strstr (indat, _("LOGKEY")))
    289     {
    290       MLOCK(item->data, (len+1));
    291       ;
    292     }
     283    MLOCK(item->data, (len+1));
    293284
    294285  sl_strlcpy (item->data, indat, len+1);
    … …  
    318309  ++(fifo->fifo_cts);
    319310
    320   SL_RETURN((0), _("push_tail_list"));
     311  SL_RETURN((fifo->fifo_cts), _("push_tail_list"));
    321312}
    322313
    … …  
    356347
    357348  if (NULL != sl_strstr (retval, _("LOGKEY")))
    358     {
    359       MUNLOCK(getit->data, (len+1));
    360       ;
    361     }
     349    MUNLOCK(getit->data, (len+1));
    362350
    363351  if (getit->s_xtra)
    … …  
    372360
    373361
    374 
    375 
     362#ifdef SH_CUTEST
     363#include "CuTest.h"
     364
     365void Test_fifo (CuTest *tc) {
     366
     367  SH_FIFO ff;
     368  int ret;
     369  char * p;
     370
     371  fifo_init(&ff);
     372
     373  p = sh_fifo_pop(&ff);
     374  CuAssertPtrEquals(tc, NULL, p);
     375
     376  /* first sequence */
     377  ret = sh_fifo_push(&ff, "one");
     378  CuAssertIntEquals(tc,1,ret);
     379  ret = sh_fifo_push(&ff, "two");
     380  CuAssertIntEquals(tc,2,ret);
     381  ret = sh_fifo_push(&ff, "three");
     382  CuAssertIntEquals(tc,3,ret);
     383
     384  p = sh_fifo_pop(&ff);
     385  CuAssertPtrNotNull(tc, p);
     386  CuAssertStrEquals(tc,"one", p);
     387  p = sh_fifo_pop(&ff);
     388  CuAssertPtrNotNull(tc, p);
     389  CuAssertStrEquals(tc,"two", p);
     390  p = sh_fifo_pop(&ff);
     391  CuAssertPtrNotNull(tc, p);
     392  CuAssertStrEquals(tc,"three", p);
     393  p = sh_fifo_pop(&ff);
     394  CuAssertPtrEquals(tc, NULL, p);
     395
     396  /* second sequence */
     397  ret = sh_fifo_push(&ff, "one");
     398  CuAssertIntEquals(tc,1,ret);
     399  p = sh_fifo_pop(&ff);
     400  CuAssertPtrNotNull(tc, p);
     401  CuAssertStrEquals(tc,"one", p);
     402  ret = sh_fifo_push_tail(&ff, "one");
     403  CuAssertIntEquals(tc,1,ret);
     404  p = sh_fifo_pop(&ff);
     405  CuAssertPtrNotNull(tc, p);
     406  CuAssertStrEquals(tc,"one", p);
     407  p = sh_fifo_pop(&ff);
     408  CuAssertPtrEquals(tc, NULL, p);
     409
     410  /* third sequence */
     411  ret = sh_fifo_push(&ff, "one");
     412  CuAssertIntEquals(tc,1,ret);
     413  ret = sh_fifo_push(&ff, "two");
     414  CuAssertIntEquals(tc,2,ret);
     415  ret = sh_fifo_push(&ff, "three");
     416  CuAssertIntEquals(tc,3,ret);
     417
     418  p = sh_fifo_pop(&ff);
     419  CuAssertPtrNotNull(tc, p);
     420  CuAssertStrEquals(tc,"one", p);
     421  ret = sh_fifo_push_tail(&ff, p);
     422  CuAssertIntEquals(tc,3,ret);
     423
     424  p = sh_fifo_pop(&ff);
     425  CuAssertPtrNotNull(tc, p);
     426  CuAssertStrEquals(tc,"one", p);
     427  p = sh_fifo_pop(&ff);
     428  CuAssertPtrNotNull(tc, p);
     429  CuAssertStrEquals(tc,"two", p);
     430  p = sh_fifo_pop(&ff);
     431  CuAssertPtrNotNull(tc, p);
     432  CuAssertStrEquals(tc,"three", p);
     433  p = sh_fifo_pop(&ff);
     434  CuAssertPtrEquals(tc, NULL, p);
     435}
     436
     437#endif
     438
     439
     440
     441

  • trunk/src/sh_files.c

    r465 r481  
    8888#include "sh_inotify.h"
    8989#include "zAVLTree.h"
     90#include "sh_dbIO.h"
    9091
    9192#undef  FIL__
    … …  
    211212}
    212213
     214char * sh_files_parse_input(const char * str_s, size_t * len)
     215{
     216  char  * p;
     217
     218  if (!str_s || *str_s == '\0')
     219    return NULL;
     220
     221  *len = sl_strlen(str_s);
     222
     223  if ( (str_s[0] == '"'  && str_s[*len-1] == '"' ) ||
     224       (str_s[0] == '\'' && str_s[*len-1] == '\'') )
     225    {
     226      if (*len < 3)
     227        return NULL;
     228      --(*len);
     229      p = sh_util_strdup_l(&str_s[1], *len);
     230      p[*len-1] = '\0';
     231      --(*len);
     232    }
     233  else
     234    {
     235      p = sh_util_strdup_l(str_s, *len);
     236    }
     237
     238  p = sh_files_C_dequote(p, len);
     239
     240  return p;
     241}
     242
     243
    213244extern int flag_err_debug;
    214245extern int flag_err_info;
    … …  
    251282  char                  * name;
    252283  int                     class;
    253   unsigned long           check_mask;
     284  unsigned long           check_flags;
    254285  int                     rdepth;
    255286  short                   checked;
    … …  
    322353    SL_RETURN((-1), _("sh_files_setrecursion"));
    323354
    324   if (sh.flag.opts == 1) 
     355  if (sh.flag.opts == S_TRUE) 
    325356    reject = 1;
    326357
    … …  
    380411                           tmp);
    381412        }
    382 #ifndef REPLACE_OLD
    383       /* this will tell that we have seen the file, and thus prevent
    384        * deletion from the database, resulting in an incomplete
    385        * message when the file reappears
    386        */
    387       if (sh.flag.checkSum != SH_CHECK_INIT)
    388         sh_hash_set_visited_true(ptr->name);
    389 #else
     413
    390414      if (sh.flag.checkSum != SH_CHECK_INIT)
    391415        sh_hash_set_missing(ptr->name);
    392 #endif
     416
    393417      if (sh.flag.reportonce == S_TRUE)
    394418        SET_SH_FFLAG_REPORTED(ptr->is_reported);
    … …  
    431455                  }
    432456                }
    433 #ifndef REPLACE_OLD
    434               if (sh.flag.checkSum != SH_CHECK_INIT)
    435                 sh_hash_set_visited_true(ptr->name);
    436 #else
     457
    437458              /* delete from database
    438459               */
    439460              if (sh.flag.checkSum != SH_CHECK_INIT)
    440461                sh_hash_set_missing(ptr->name);
    441 #endif
    442462            }
    443463          else
    … …  
    494514
    495515         
    496           if (flag_err_info == SL_TRUE)
     516          if (flag_err_info == S_TRUE)
    497517            {
    498518              char pstr[32];
    … …  
    508528            {
    509529              sh_inotify_add_watch_later(ptr->name, &sh_file_watches, NULL,
    510                                          ptr->class, ptr->check_mask,
     530                                         ptr->class, ptr->check_flags,
    511531                                         SH_INOTIFY_FILE, 0);
    512532            }
    … …  
    514534          BREAKEXIT(sh_files_filecheck);
    515535          tmp_reported = ptr->is_reported; /* fix aliasing warning */
    516           status = sh_files_filecheck (ptr->class, ptr->check_mask, dir, file,
     536          status = sh_files_filecheck (ptr->class, ptr->check_flags, dir, file,
    517537                                       &tmp_reported, 0);
    518538          ptr->is_reported = tmp_reported;
    … …  
    590610}
    591611
    592 static void * sh_dummy_candidate;
     612void * sh_dummy_621_candidate;
    593613
    594614static char * intern_find_morespecific_dir(zAVLTree * tree,
    … …  
    605625    return NULL;
    606626
    607   sh_dummy_candidate = (void *) &candidate;
     627  sh_dummy_621_candidate = (void *) &candidate;
    608628
    609629  SH_MUTEX_LOCK(mutex_zfiles);
    … …  
    10691089
    10701090int sh_files_push_file_int (int class, const char * str_s, size_t len,
    1071                             unsigned long check_mask)
     1091                            unsigned long check_flags)
    10721092{
    10731093  dirstack_t * new_item_ptr;
    … …  
    10851105  new_item_ptr->name           = fileName;
    10861106  new_item_ptr->class          = class;
    1087   new_item_ptr->check_mask     = check_mask;
     1107  new_item_ptr->check_flags     = check_flags;
    10881108  new_item_ptr->rdepth         = 0;
    10891109  new_item_ptr->checked        = S_FALSE;
    … …  
    11221142    {
    11231143      int           reported;
    1124       unsigned long check_mask = sh_files_maskof(class);
     1144      unsigned long check_flags = sh_files_maskof(class);
    11251145
    11261146      if ((sh.flag.inotify & SH_INOTIFY_INSCAN) != 0)
    11271147        {
    1128           sh_files_filecheck (class, check_mask, str_s, NULL,
     1148          sh_files_filecheck (class, check_flags, str_s, NULL,
    11291149                              &reported, 0);
    11301150          if (SH_FFLAG_REPORTED_SET(reported))
    11311151            sh_files_set_file_reported(str_s);
    11321152          sh_inotify_add_watch_later(str_s, &sh_file_watches, NULL,
    1133                                      class, check_mask,
     1153                                     class, check_flags,
    11341154                                     SH_INOTIFY_FILE, 0);
    11351155        }
    11361156
    1137       if (MODI_AUDIT_ENABLED(check_mask))
     1157      if (MODI_AUDIT_ENABLED(check_flags))
    11381158        {
    11391159          sh_audit_mark(str_s);
    … …  
    11441164}
    11451165
    1146 int sh_files_push_dir_int (int class, char * tail, size_t len, int rdepth, unsigned long check_mask);
     1166int sh_files_push_dir_int (int class, char * tail, size_t len, int rdepth, unsigned long check_flags);
    11471167
    11481168#ifdef HAVE_GLOB_H
    … …  
    11511171  char                  * name;
    11521172  int                     class;
    1153   unsigned long           check_mask;
     1173  unsigned long           check_flags;
    11541174  int                     rdepth;
    11551175  short                   type;
    … …  
    11601180
    11611181static int sh_files_pushglob (int class, int type, const char * p, int rdepth,
    1162                                unsigned long check_mask_in, int flag)
     1182                               unsigned long check_flags_in, int flag)
    11631183{
    11641184  int     globstatus = -1;
    … …  
    11671187
    11681188  volatile int     count = 0;
    1169   volatile unsigned long check_mask = (flag == 0) ? sh_files_maskof(class) : check_mask_in;
     1189  volatile unsigned long check_flags = (flag == 0) ? sh_files_maskof(class) : check_flags_in;
    11701190 
    11711191  SL_ENTER(_("sh_files_pushglob"));
    … …  
    11901210          new_item_ptr->name           = fileName;
    11911211          new_item_ptr->class          = class;
    1192           new_item_ptr->check_mask     = check_mask;
     1212          new_item_ptr->check_flags     = check_flags;
    11931213          new_item_ptr->rdepth         = rdepth;
    11941214          new_item_ptr->type           = type;
    … …  
    12191239            {
    12201240              count += sh_files_push_file_int (class, pglob.gl_pathv[gloop],
    1221                                                sl_strlen(pglob.gl_pathv[gloop]), check_mask);
     1241                                               sl_strlen(pglob.gl_pathv[gloop]), check_flags);
    12221242            }
    12231243          else
    … …  
    12261246
    12271247              count += sh_files_push_dir_int  (class, pglob.gl_pathv[gloop],
    1228                                                sl_strlen(pglob.gl_pathv[gloop]), rdepth, check_mask);
     1248                                               sl_strlen(pglob.gl_pathv[gloop]), rdepth, check_flags);
    12291249            }
    12301250        }
    … …  
    12851305          sh_files_pushglob(testPattern->class, testPattern->type,
    12861306                            testPattern->name, testPattern->rdepth,
    1287                             testPattern->check_mask, 1);
     1307                            testPattern->check_flags, 1);
    12881308        }
    12891309    }
    … …  
    13061326      sh_files_pushglob(testPattern->class, testPattern->type,
    13071327                        testPattern->name, testPattern->rdepth,
    1308                         testPattern->check_mask, 1);
     1328                        testPattern->check_flags, 1);
    13091329    }
    13101330  SH_MUTEX_UNLOCK(mutex_zglob);
    … …  
    13701390   * is the only one -- and will stay the only one
    13711391   */
    1372   if (sh.flag.opts == 1)
     1392  if (sh.flag.opts == S_TRUE)
    13731393    {
    13741394      sh_files_delfilestack ();
    … …  
    13781398    }
    13791399
    1380   if (str_s == NULL || str_s[0] == '\0')
    1381     SL_RETURN((-1),_("sh_files_pushfile"));
    1382 
    1383   len = sl_strlen(str_s);
    1384 
    1385   if ( (str_s[0] == '"'  && str_s[len-1] == '"' ) ||
    1386        (str_s[0] == '\'' && str_s[len-1] == '\'') )
    1387     {
    1388       if (len < 3)
    1389         SL_RETURN((-1),_("sh_files_pushfile"));
    1390       --len;
    1391       p = sh_util_strdup_l(&str_s[1], len);
    1392       p[len-1] = '\0';
    1393       --len;
    1394     }
    1395   else
    1396     {
    1397       p = sh_util_strdup_l(str_s, len);
    1398     }
    1399 
    1400   p = sh_files_C_dequote(p, &len);
     1400  p = sh_files_parse_input(str_s, &len);
    14011401  if (!p || len == 0)
    14021402    SL_RETURN((-1), _("sh_files_pushfile"));
    … …  
    14911491}
    14921492
    1493 static void * sh_dummy_ptr;
     1493void * sh_dummy_1493_ptr;
    14941494
    14951495unsigned long sh_dirs_chk (int which)
    … …  
    15071507  SL_ENTER(_("sh_dirs_chk"));
    15081508
    1509   sh_dummy_ptr = (void *) &ptr;
     1509  sh_dummy_1493_ptr = (void *) &ptr;
    15101510 
    15111511  SH_MUTEX_RECURSIVE_INIT(mutex_zdirs);
    … …  
    15361536                  BREAKEXIT(sh_files_filecheck);
    15371537                  tmp_reported = dst_ptr->is_reported;
    1538                   filetype = sh_files_filecheck (dst_ptr->class, dst_ptr->check_mask,
     1538                  filetype = sh_files_filecheck (dst_ptr->class, dst_ptr->check_flags,
    15391539                                                 ptr->name, 
    15401540                                                 NULL,  &tmp_reported, 0);
    … …  
    15551555            {
    15561556              tmp_reported = ptr->is_reported;
    1557               filetype = sh_files_filecheck (ptr->class,  ptr->check_mask,
     1557              filetype = sh_files_filecheck (ptr->class,  ptr->check_flags,
    15581558                                             ptr->name,  NULL,  &tmp_reported, 0);
    15591559              ptr->is_reported = tmp_reported;
    … …  
    15621562
    15631563          BREAKEXIT(sh_files_checkdir);
    1564           status = sh_files_checkdir (ptr->class, ptr->check_mask,
     1564          status = sh_files_checkdir (ptr->class, ptr->check_flags,
    15651565                                      ptr->rdepth, ptr->name,
    15661566                                      ptr->name);
    … …  
    17101710}
    17111711
    1712 int sh_files_push_dir_int (int class, char * tail, size_t len, int rdepth, unsigned long check_mask)
     1712int sh_files_push_dir_int (int class, char * tail, size_t len, int rdepth, unsigned long check_flags)
    17131713{
    17141714  zAVLTree   * tree;
    … …  
    17261726  new_item_ptr->name           = dirName;
    17271727  new_item_ptr->class          = class;
    1728   new_item_ptr->check_mask     = check_mask;
     1728  new_item_ptr->check_flags     = check_flags;
    17291729  new_item_ptr->rdepth         = rdepth;
    17301730  new_item_ptr->checked        = S_FALSE;
    … …  
    17761776  else
    17771777    {
    1778       if (MODI_AUDIT_ENABLED(check_mask))
     1778      if (MODI_AUDIT_ENABLED(check_flags))
    17791779        {
    17801780          sh_audit_mark(tail);
    … …  
    17941794  SL_ENTER(_("sh_files_pushdir"));
    17951795
    1796   if (sh.flag.opts == 1) {
     1796  if (sh.flag.opts == S_TRUE) {
    17971797    sh_files_delfilestack ();
    17981798    sh_files_deldirstack ();
    … …  
    18001800  }
    18011801
    1802   if (str_s == NULL || str_s[0] == '\0')
     1802  p = sh_files_parse_input(str_s, &len);
     1803  if (!p || len == 0)
    18031804    SL_RETURN((-1),_("sh_files_pushdir"));
    1804 
    1805   len = sl_strlen(str_s);
    1806 
    1807   if ( (str_s[0] == '"'  && str_s[len-1] == '"' ) ||
    1808        (str_s[0] == '\'' && str_s[len-1] == '\'') )
    1809     {
    1810       if (len < 3)
    1811         SL_RETURN((-1),_("sh_files_pushdir"));
    1812       --len;
    1813       p = sh_util_strdup_l(&str_s[1], len);
    1814       p[len-1] = '\0';
    1815       --len;
    1816     }
    1817   else
    1818     {
    1819       p = sh_util_strdup_l(str_s, len);
    1820     }
    1821 
    1822   p = sh_files_C_dequote(p, &len);
    1823   if (!p || len == 0)
    1824     SL_RETURN((-1), _("sh_files_pushdir"));
    18251805
    18261806  if (p[0] != '/')
    … …  
    20482028 *    check the directory inode itself.
    20492029 */
    2050 int sh_files_checkdir (int iclass, unsigned long check_mask,
     2030int sh_files_checkdir (int iclass, unsigned long check_flags,
    20512031                       int idepth, char * iname,
    20522032                       char * relativeName)
    … …  
    20732053  volatile int    class_next;
    20742054  volatile int    file_class_next;
    2075   volatile unsigned long   check_mask_next;
    2076   volatile unsigned long   file_check_mask_next;
     2055  volatile unsigned long   check_flags_next;
     2056  volatile unsigned long   file_check_flags_next;
    20772057
    20782058  volatile int    checked_flag  = S_FALSE;
    … …  
    21142094    }
    21152095
    2116   if (flag_err_info == SL_TRUE)
     2096  if (flag_err_info == S_TRUE)
    21172097    {
    21182098      char pstr[32];
    … …  
    21492129  theFile->attr_string = NULL;
    21502130  theFile->link_path   = NULL;
    2151   theFile->check_mask  = check_mask;
     2131  theFile->check_flags  = check_flags;
    21522132
    21532133  (void) relativeName;
    … …  
    21902170    {
    21912171      sh_inotify_add_watch_later(iname, &sh_file_watches, &status,
    2192                                  iclass, check_mask, SH_INOTIFY_DIR, idepth);
     2172                                 iclass, check_flags, SH_INOTIFY_DIR, idepth);
    21932173    }
    21942174   
    … …  
    23012281    rdepth_next     = rdepth - 1;
    23022282    class_next      = class;
    2303     check_mask_next = check_mask;
     2283    check_flags_next = check_flags;
    23042284    file_class_next = class;
    2305     file_check_mask_next = check_mask;
     2285    file_check_flags_next = check_flags;
    23062286    checked_flag    = -1;
    23072287    cchecked_flag   = -1;
    … …  
    23222302         */
    23232303        file_class_next    = dst_ptr->class;
    2324         file_check_mask_next = dst_ptr->check_mask;
     2304        file_check_flags_next = dst_ptr->check_flags;
    23252305        checked_flag       = dst_ptr->checked;
    23262306        cchecked_flag      = dst_ptr->childs_checked;
    … …  
    23382318             */
    23392319            file_class_next    = dst_ptr->class;
    2340             file_check_mask_next = dst_ptr->check_mask;
     2320            file_check_flags_next = dst_ptr->check_flags;
    23412321            checked_flag       = dst_ptr->checked;
    23422322            cchecked_flag      = dst_ptr->childs_checked;
    … …  
    23552335         */
    23562336        file_class_next    = dst_ptr->class;
    2357         file_check_mask_next = dst_ptr->check_mask;
     2337        file_check_flags_next = dst_ptr->check_flags;
    23582338        checked_flag       = dst_ptr->checked;
    23592339        /* not set, hence always FALSE                   */
    … …  
    24032383         */
    24042384
    2405         checkit = sh_files_filecheck (file_class_next, file_check_mask_next,
     2385        checkit = sh_files_filecheck (file_class_next, file_check_flags_next,
    24062386                                      iname,
    24072387                                      dirlist->sh_d_name,
    … …  
    24532433                rdepth_next   = tmp_ptr->rdepth;
    24542434                class_next    = tmp_ptr->class;
    2455                 check_mask_next = tmp_ptr->check_mask;
     2435                check_flags_next = tmp_ptr->check_flags;
    24562436                /* 28. Aug 2001 reversed
    24572437                 */
    … …  
    24712451                    rdepth_next   = tmp_ptr->rdepth;
    24722452                    class_next    = tmp_ptr->class;
    2473                     check_mask_next = tmp_ptr->check_mask;
     2453                    check_flags_next = tmp_ptr->check_flags;
    24742454                    /* 28. Aug 2001 reversed
    24752455                     */
    … …  
    24912471            if (cchecked_flag == S_FALSE)
    24922472              {
    2493                 sh_files_checkdir (class_next, check_mask_next, rdepth_next,
     2473                sh_files_checkdir (class_next, check_flags_next, rdepth_next,
    24942474                                   tmpcat, dirlist->sh_d_name);
    24952475                /*
    … …  
    24992479              }
    25002480            else if (checked_flag == -1)
    2501               sh_files_checkdir (class_next, check_mask_next, rdepth_next,
     2481              sh_files_checkdir (class_next, check_flags_next, rdepth_next,
    25022482                                 tmpcat, dirlist->sh_d_name);
    25032483           
    … …  
    25322512  } while (dirlist != NULL);
    25332513
    2534   if (flag_err_info == SL_TRUE)
     2514  if (flag_err_info == S_TRUE)
    25352515    {
    25362516      sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_DSUM,
    … …  
    25762556}
    25772557
     2558void sh_files_fixup_mask (int class, unsigned long * check_flags)
     2559{
     2560  if (class == SH_LEVEL_ALLIGNORE)
     2561    MODI_SET((*check_flags), MODI_ALLIGNORE);
     2562  sh_tiger_get_mask_hashtype(check_flags);
     2563  return;
     2564}
     2565
    25782566int get_the_fd (SL_TICKET ticket);
    25792567
    … …  
    25892577static void * sh_dummy_tmpdir;
    25902578
    2591 ShFileType sh_files_filecheck (int class, unsigned long check_mask,
     2579ShFileType sh_files_filecheck (int class, unsigned long check_flags,
    25922580                               const char * dirName,
    25932581                               const char * infileName,
    … …  
    27012689   */
    27022690  sl_strlcpy (theFile->fullpath, fullpath, PATH_MAX);
    2703   theFile->check_mask    = check_mask /* sh_files_maskof(class) */;
     2691  theFile->check_flags    = check_flags /* sh_files_maskof(class) */;
    27042692  theFile->file_reported = (*reported);
    27052693  theFile->attr_string   = NULL;
    … …  
    27122700                             fileName,
    27132701                             theFile, fileHash, class);
    2714  
     2702
    27152703  if (status != 0)
    27162704    {
    … …  
    27322720  /* report
    27332721   */
    2734   if ((flag_err_debug == SL_TRUE) && (theFile->c_mode[0] == '-'))
     2722  if ((flag_err_debug == S_TRUE) && (theFile->c_mode[0] == '-'))
    27352723    {
    27362724      tmpname = sh_util_safe_name (fullpath); /* fixed in 1.5.4 */
    … …  
    27432731  ++sh.statistics.files_checked;
    27442732     
    2745   if ( sh.flag.checkSum == SH_CHECK_INIT /* && sh.flag.update == S_FALSE */)
    2746     {
    2747       sh_hash_pushdata (theFile, fileHash);
     2733  if ( sh.flag.checkSum == SH_CHECK_INIT)
     2734    {
     2735      if (class == SH_LEVEL_ALLIGNORE)
     2736        MODI_SET(theFile->check_flags, MODI_ALLIGNORE);
     2737      if (S_TRUE == sh_ignore_chk_mod(theFile->fullpath))
     2738        MODI_SET(theFile->check_flags, MODI_NOCHECK);
     2739      sh_tiger_get_mask_hashtype(&(theFile->check_flags));
     2740      sh_dbIO_data_write (theFile, fileHash);
    27482741    }
    27492742  else if (sh.flag.checkSum == SH_CHECK_CHECK
    … …  
    27522745           )
    27532746    {
     2747      if (sh.flag.update == S_TRUE)
     2748        {
     2749          if (class == SH_LEVEL_ALLIGNORE)
     2750            MODI_SET(theFile->check_flags, MODI_ALLIGNORE);
     2751          if (S_TRUE == sh_ignore_chk_mod(theFile->fullpath))
     2752            MODI_SET(theFile->check_flags, MODI_NOCHECK);
     2753          sh_tiger_get_mask_hashtype(&(theFile->check_flags));
     2754        }
    27542755      sh_hash_compdata (class, theFile, fileHash, NULL, -1);
    27552756    }
    … …  
    27602761   */
    27612762#if !defined(O_NOATIME)
    2762   if (class == SH_LEVEL_NOIGNORE && (theFile->check_mask & MODI_ATM) != 0)
     2763  if (class == SH_LEVEL_NOIGNORE && (theFile->check_flags & MODI_ATM) != 0)
    27632764    {
    27642765      utime_buf.actime   = (time_t) theFile->atime;
    … …  
    27922793          if (S_TRUE == sh_unix_file_exists (testpath))
    27932794            {
    2794               sh_files_filecheck (class, check_mask, fullpath, rsrc, &dummy, 1);
     2795              sh_files_filecheck (class, check_flags, fullpath, rsrc, &dummy, 1);
    27952796            }
    27962797        }
    … …  
    28602861 */
    28612862int sh_files_search_dir(char * name, int * class,
    2862                         unsigned long *check_mask, int *reported,
     2863                        unsigned long *check_flags, int *reported,
    28632864                        int * rdepth)
    28642865{
    … …  
    28772878  if (item)
    28782879    {
    2879       *check_mask = item->check_mask;
     2880      *check_flags = item->check_flags;
    28802881      *class      = item->class;
    28812882      *reported   = item->is_reported;
    … …  
    28922893  if (item)
    28932894    {
    2894       *check_mask = item->check_mask;
     2895      *check_flags = item->check_flags;
    28952896      *class      = item->class;
    28962897      *reported   = item->is_reported;
    … …  
    29142915          if (0 == fnmatch(testPattern->name, name, FNM_PATHNAME|FNM_PERIOD))
    29152916            {
    2916               *check_mask = testPattern->check_mask;
     2917              *check_flags = testPattern->check_flags;
    29172918              *class      = testPattern->class;
    29182919              *rdepth     = testPattern->rdepth;
    … …  
    29322933
    29332934int sh_files_search_file(char * name, int * class,
    2934                          unsigned long *check_mask, int *reported)
     2935                         unsigned long *check_flags, int *reported)
    29352936{
    29362937  volatile int retval = 0;
    … …  
    29462947  if (item)
    29472948    {
    2948       *check_mask = item->check_mask;
     2949      *check_flags = item->check_flags;
    29492950      *class      = item->class;
    29502951      *reported   = item->is_reported;
    … …  
    29662967                               FNM_PATHNAME|FNM_PERIOD))
    29672968                {
    2968                   *check_mask = testPattern->check_mask;
     2969                  *check_flags = testPattern->check_flags;
    29692970                  *class      = testPattern->class;
    29702971                  retval = 1;
    … …  
    30353036    {
    30363037      if (0 == strcmp(name, pfilL->name) &&
    3037           (pfilL->check_mask & MODI_ATM) == 0 &&
    3038           (pfilL->check_mask & MODI_CTM) == 0 &&
    3039           (pfilL->check_mask & MODI_MTM) == 0)
     3038          (pfilL->check_flags & MODI_ATM) == 0 &&
     3039          (pfilL->check_flags & MODI_CTM) == 0 &&
     3040          (pfilL->check_flags & MODI_MTM) == 0)
    30403041        {
    30413042          retval = 0;
    … …  
    30873088                  (0 == strncmp(pfilL->name, pdirL->name, dlen)))
    30883089                {
    3089                   if ((pdirL->check_mask & MODI_ATM) != 0  ||
    3090                       (pdirL->check_mask & MODI_MTM) != 0  ||
    3091                       (pdirL->check_mask & MODI_CTM) != 0)
     3090                  if ((pdirL->check_flags & MODI_ATM) != 0  ||
     3091                      (pdirL->check_flags & MODI_MTM) != 0  ||
     3092                      (pdirL->check_flags & MODI_CTM) != 0)
    30923093                    {
    30933094                      if (check_file (pdirL->name) != 0)

  • trunk/src/sh_filetype.c

    r454 r481  
    406406    }
    407407
    408   /* fprintf(stderr, "FIXME: %d %d %s ", dtype, length, type); */
    409   /**
    410   if (dtype == 0)
    411     fprintf(stderr, "%s\n", pattern);
    412   else
    413     {
    414       int k;
    415       for (k = 0; k < length; ++k)
    416         fprintf(stderr, "0x%X", (unsigned int) (pattern[k]));
    417       fprintf(stderr, "\n");
    418     }
    419   **/
    420 
    421408  for (i = 0; i < n; ++i)
    422409    {
    … …  
    523510          p = &buffer[sh_ftype_arr[i]->offset];
    524511
    525 #if 0
    526           {
    527             int dd;
    528             /* fprintf(stderr, "FIXME: %03d comp %d:%d  ", i,
    529                sh_ftype_arr[i]->offset, sh_ftype_arr[i]->length); */
    530             for (dd = 0; dd < sh_ftype_arr[i]->length; ++dd) {
    531               fprintf(stderr, "0x%X ", sh_ftype_arr[i]->pattern[dd]);
    532             }
    533             for (dd = 0; dd < sh_ftype_arr[i]->length; ++dd) {
    534               fprintf(stderr, "0x%X ", p[dd]);
    535             }
    536             fprintf(stderr, "\n");
    537           }
    538 #endif
    539 
    540512          if (0 == memcmp(p, sh_ftype_arr[i]->pattern, sh_ftype_arr[i]->length))
    541513            {
    … …  
    582554  long len;
    583555
    584   len = sl_read_timeout (ft, buffer, sizeof(buffer), 12, SL_TRUE);
     556  len = sl_read_timeout (ft, buffer, sizeof(buffer), 12, S_TRUE);
    585557
    586558  sl_rewind(ft);

  • trunk/src/sh_getopt.c

    r467 r481  
    3434#include "sh_utils.h"
    3535#include "sh_mail.h"
    36 #include "sh_forward.h"
     36#include "sh_xfer.h"
    3737#include "sh_hash.h"
     38#include "sh_dbIO.h"
     39#include "sh_dbCheck.h"
     40#include "sh_dbCreate.h"
     41#include "sh_sem.h"
    3842
    3943#if defined(WITH_EXTERNAL)
    … …  
    6468#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
    6569static int sh_getopt_forever (const char * dummy);
     70static int sh_getopt_outpath (const char * dummy);
    6671#endif
    6772static int sh_getopt_copyright (const char * dummy);
    … …  
    9297    N_("Set the server port to connect to"), 
    9398    HAS_ARG_YES,
    94     sh_forward_server_port },
     99    sh_xfer_server_port },
    95100  { N_("server-host"), 
    96101    '-',
    97102    N_("Set the server host to connect to"), 
    98103    HAS_ARG_YES,
    99     sh_forward_setlogserver },
     104    sh_xfer_set_logserver },
    100105#endif
    101106#ifdef SH_WITH_SERVER
    … …  
    109114    N_("Log fully qualified name of client host"), 
    110115    HAS_ARG_NO,
    111     sh_forward_set_strip },
     116    sh_xfer_set_strip },
    112117  { N_("chroot"), 
    113118    '-',
    … …  
    222227    N_("Compute a client registry entry for password"), 
    223228    HAS_ARG_YES,
    224     sh_forward_make_client },
     229    sh_xfer_make_client },
    225230  { N_("gen-password"), 
    226231    'G',
    227232    N_("Generate a random password"), 
    228233    HAS_ARG_NO,
    229     sh_forward_create_password },
     234    sh_xfer_create_password },
    230235#endif
    231236
    … …  
    236241    HAS_ARG_NO,
    237242    sh_getopt_forever},
     243  { N_("outfile"), 
     244    'o',
     245    N_("Pathname for output file"), 
     246    HAS_ARG_YES,
     247    sh_getopt_outpath},
    238248  { N_("list-file"), 
    239249    '-',
    240     N_("Modify -d to list content of a single file"), 
     250    N_("Modify -d to show content of a single file"), 
    241251    HAS_ARG_YES,
    242252    set_list_file},
     253  { N_("list-filter"), 
     254    '-',
     255    N_("Modify -d to filter by file list given in text file"), 
     256    HAS_ARG_YES,
     257    sh_dbIO_list_filter},
    243258  { N_("full-detail"), 
    244259    'a',
    245     N_("Modify -d to list full details"), 
     260    N_("Modify -d to show full details"), 
    246261    HAS_ARG_NO,
    247262    set_full_detail},
    248263  { N_("delimited"), 
    249264    '-',
    250     N_("Modify -d to list full details, comma delimited"), 
     265    N_("Modify -d to show full details, comma delimited"), 
    251266    HAS_ARG_NO,
    252267    set_list_delimited},
     268  { N_("binary"), 
     269    '-',
     270    N_("Modify -d to output in binary database format"), 
     271    HAS_ARG_NO,
     272    sh_dbIO_list_binary},
    253273  { N_("list-database"), 
    254274    'd',
    255275    N_("List database content (like ls -l)"), 
    256276    HAS_ARG_YES,
    257     sh_hash_list_db},
     277    sh_dbIO_list_db},
    258278  { N_("init2stdout"), 
    259279    '-',
    260280    N_("Write database to stdout on init"), 
    261281    HAS_ARG_NO,
    262     sh_hash_pushdata_stdout},
     282    sh_dbIO_writeout_stdout},
     283  { N_("verify-database"), 
     284    '-',
     285    N_("Verify the given database"), 
     286    HAS_ARG_YES,
     287    sh_dbCheck_verify},
     288  { N_("create-database"), 
     289    '-',
     290    N_("Create database from file list"), 
     291    HAS_ARG_YES,
     292    sh_dbCreate},
     293  { N_("wait-on-check"), 
     294    'w',
     295    N_("Timed wait for end of filecheck (0 for no timeout)"), 
     296    HAS_ARG_YES,
     297    sh_sem_wait},
    263298#endif
    264299  { N_("trace-logfile"), 
    … …  
    744779  sh.flag.loop = S_TRUE;
    745780  SL_RETURN(0, _("sh_getopt_forever"));
     781}
     782
     783static int sh_getopt_outpath (const char * str)
     784{
     785  if (str)
     786    {
     787      if (sh.outpath)
     788        SH_FREE(sh.outpath);
     789      sh.outpath = sh_util_strdup(str);
     790      return 0;
     791    }
     792  return -1;
    746793}
    747794#endif 

  • trunk/src/sh_gpg.c

    r474 r481  
    6060#include "sh_static.h"
    6161#endif
     62#include "sh_gpg.h"
    6263
    6364static struct {
    … …  
    128129  SL_ENTER(_("sh_gpg_checksum"));
    129130
    130 #if defined(WITH_PGP)
    131   test_gpg = sh_tiger_hash_gpg (DEFAULT_PGP_PATH, checkfd, TIGER_NOLIM);
    132 #else
    133131  test_gpg = sh_tiger_hash_gpg (DEFAULT_GPG_PATH, checkfd, TIGER_NOLIM);
    134 #endif
    135132 
    136133  test_ptr1 = strchr(GPG_HASH, ':');
    … …  
    252249  char   cc1[32];
    253250  char   cc2[32];
    254 #if defined(WITH_PGP)
    255   char   cc3[32];
    256   char   cc0[3] = "-f";
    257 #endif
    258 #if defined(WITH_GPG)
     251
    259252  char   cc0[2] = "-";
    260253  char   cc3[32];
    261254  char   cc4[SH_PATHBUF+32];
    262255  char   cc5[32];
    263 #endif
     256
    264257
    265258  char * arg[9];
    … …  
    279272  SL_ENTER(_("sh_gpg_popen"));
    280273
    281 #if defined(WITH_GPG)
    282274  /* -- GnuPG -- */
    283275  sl_strlcpy (path,  DEFAULT_GPG_PATH,  256);
    … …  
    387379  (void) mode;
    388380  (void) id;
    389 #elif defined(WITH_PGP)
    390   /* -- PGP -- */
    391   sl_strlcpy (path,  DEFAULT_PGP_PATH, 256);
    392   if (mode == 0)
    393     {
    394       sl_strlcpy (cc1,   _("+language=en"),  32);
    395       sl_strlcpy (cc2,   _("-o"),     32);
    396       sl_strlcpy (cc3,   _("/dev/null"),     32);
    397      
    398       arg[0] = path;
    399       arg[1] = cc1;
    400       arg[2] = cc2;
    401       arg[3] = cc3;
    402       arg[4] = cc0;
    403       arg[5] = NULL;
    404     }
    405   else
    406     {
    407       sl_strlcpy (cc1,   _("+language=en"),  32);
    408       sl_strlcpy (cc2,   _("-kvc"),     32);       
    409      
    410       arg[0] = path;
    411       arg[1] = cc1;
    412       arg[2] = cc2;
    413       arg[3] = id;
    414       arg[4] = NULL;
    415       arg[5] = NULL;
    416     }
    417 #endif
    418381
    419382  /* use homedir of effective user
    … …  
    467430      sl_close_fd (FIL__, __LINE__, pipedes[STDOUT_FILENO]);
    468431     
    469 
    470 #if defined(WITH_PGP)
    471       if (mode == 0)
    472         {
    473           if (retry_aud_dup2(FIL__, __LINE__, fd, STDIN_FILENO) < 0)
    474             {
    475               TPT(((0), FIL__, __LINE__, _("msg=<dup2 on fd failed>\n")));
    476               dlog(1, FIL__, __LINE__, _("Internal error: dup2 failed\n"));
    477               aud__exit(FIL__, __LINE__, EXIT_FAILURE);
    478             }
    479         }
    480 #else
    481432      if (retry_aud_dup2(FIL__, __LINE__, fd, STDIN_FILENO) < 0)
    482433        {
    … …  
    485436          aud__exit(FIL__, __LINE__, EXIT_FAILURE);
    486437        }
    487 #endif
    488438 
    489439      /* don't leak file descriptors
    490440       */
    491       sh_unix_closeall (3, -1, SL_TRUE); /* in child process */
    492 
    493       if (flag_err_debug != SL_TRUE)
     441      sh_unix_closeall (3, -1, S_TRUE); /* in child process */
     442
     443      if (flag_err_debug != S_TRUE)
    494444        {
    495445          if (NULL == freopen(_("/dev/null"), "r+", stderr))
    … …  
    530480       * --  emulate an fexecve with checksum testing
    531481       */
    532 #if defined(WITH_PGP)
    533       checkfd = sl_open_read(FIL__, __LINE__, DEFAULT_PGP_PATH, SL_NOPRIV);
    534 #else
    535482      checkfd = sl_open_read(FIL__, __LINE__, DEFAULT_GPG_PATH, SL_NOPRIV);
    536 #endif
    537483
    538484      if (0 != sh_gpg_checksum(checkfd, 0))
    … …  
    580526      for (i = 0; i < myrand; ++i)
    581527        {
    582 #if defined(WITH_PGP)
    583           checkfd = sl_open_fastread(FIL__, __LINE__, DEFAULT_PGP_PATH, SL_NOPRIV);
    584 #else
    585           checkfd = sl_open_fastread(FIL__, __LINE__, DEFAULT_GPG_PATH, SL_NOPRIV);
    586 #endif
     528          checkfd = sl_open_fastread(FIL__, __LINE__,
     529                                     DEFAULT_GPG_PATH, SL_NOPRIV);
     530
    587531          if (0 != sh_gpg_checksum(checkfd, 0)) {
    588532            aud__exit(FIL__, __LINE__, EXIT_FAILURE);
    … …  
    591535        }
    592536#endif
    593                                
    594 
    595 #if defined(WITH_GPG)
     537
    596538      retry_aud_execve (FIL__, __LINE__, DEFAULT_GPG_PATH, arg, envp);
    597539      dlog(1, FIL__, __LINE__, _("Unexpected error: execve %s failed\n"),
    598540           DEFAULT_GPG_PATH);
    599 #elif defined(WITH_PGP)
    600       retry_aud_execve (FIL__, __LINE__, DEFAULT_PGP_PATH, arg, envp);
    601 #endif
    602541     
    603542      /* failed
    … …  
    659598  sh_gpg_popen_t  source;
    660599  int have_id = BAD, have_fp = BAD, status = 0;
    661 #ifdef WITH_PGP
    662   char *ptr;
    663 #endif
    664600
    665601#ifdef HAVE_GPG_CHECKSUM
    … …  
    671607  /* check whether GnuPG exists and has the correct checksum
    672608   */
    673 #if defined(WITH_GPG)
    674 
    675609  TPT(((0), FIL__, __LINE__, _("msg=<Check signature>\n")));
    676610  TPT(((0), FIL__, __LINE__, _("msg=<gpg is %s>\n"), DEFAULT_GPG_PATH));
    … …  
    701635    }
    702636  sl_close(checkfd);
    703 #endif
    704 
    705 #elif defined(WITH_PGP)
    706 
    707   TPT(((0), FIL__, __LINE__, _("msg=<Check signature>\n")));
    708   TPT(((0), FIL__, __LINE__, _("msg=<pgp is %s>\n"), DEFAULT_PGP_PATH));
    709 
    710   if (0 != retry_lstat(FIL__, __LINE__, DEFAULT_PGP_PATH, &buf))
    711     {
    712       char errbuf[SH_ERRBUF_SIZE];
    713 
    714       status = errno;
    715       sh_error_handle(SH_ERR_ERR, FIL__, __LINE__, status, MSG_ERR_LSTAT,
    716                       sh_error_message(status, errbuf, sizeof(errbuf)), DEFAULT_PGP_PATH);
    717       SL_RETURN( SH_GPG_BAD, _("sh_gpg_check_file_sign"));
    718     }
    719   if (0 != tf_trust_check (DEFAULT_PGP_PATH, SL_YESPRIV))
    720     SL_RETURN( SH_GPG_BAD, _("sh_gpg_check_file_sign"));
    721 
    722 #ifdef HAVE_GPG_CHECKSUM
    723   checkfd = sl_open_read(FIL__, __LINE__, DEFAULT_PGP_PATH, SL_YESPRIV);
    724 
    725   if (0 != sh_gpg_checksum(checkfd, 1))
    726     {
    727       sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
    728                       _("Checksum mismatch"),
    729                       _("gpg_check_file_sign"));
    730       sl_close(checkfd);
    731       SL_RETURN( SH_GPG_BAD, _("sh_gpg_check_file_sign"));
    732     }
    733   sl_close(checkfd);
    734 #endif
    735 
    736637#endif
    737638
    … …  
    768669      if (sl_strlen(line) < 18)
    769670        continue;
    770 #if defined(WITH_GPG)
     671
    771672      /* Sun May 27 18:40:05 CEST 2001
    772673       */
    … …  
    821722          have_fp = GOOD;
    822723        }
    823 #elif defined(WITH_PGP)
    824       if (0 == sl_strncmp(_("Bad signature"), line, 13) ||
    825           0 == sl_strncmp(_("Error"), line, 5) ||
    826           0 == sl_strncmp(_("Malformed"), line, 9) ||
    827           0 == sl_strncmp(_("WARNING"), line, 7) ||
    828           0 == sl_strncmp(_("ERROR"), line, 5)
    829           )
    830         {
    831           have_fp = BAD; have_id = BAD;
    832           break;
    833         }
    834       if (0 == sl_strncmp(_("Good signature"), line, 14))
    835         {
    836           ptr = strchr ( line, '"');
    837           ++ptr;
    838           if (ptr)
    839             {
    840               sl_strlcpy (sign_id, ptr, SH_MINIBUF+1);
    841               sign_id[sl_strlen(sign_id)-1] = '\0'; /* remove trailing dot */
    842               sign_id[sl_strlen(sign_id)-2] = '\0'; /* remove trailing '"' */
    843             }
    844           else
    845             {
    846               sl_strlcpy (sign_id, _("(null)"), SH_MINIBUF+1);
    847             }
    848           have_id = GOOD;
    849         }
    850 #endif
    851724    }
    852725
    853726  if (ferror(source.pipe) && errno == EAGAIN)
    854727    {
    855       retry_msleep(0,10); /* sleep 10 ms to avoid starving the gpg child writing to the pipe */
     728      /* sleep 10 ms to avoid starving the gpg child writing to the pipe */
     729      retry_msleep(0,10);
    856730      clearerr(source.pipe);
    857731      goto xagain;
    … …  
    862736  TPT(((0), FIL__, __LINE__, _("msg=<Close pipe>\n")));
    863737
    864 #ifdef WITH_PGP
    865   /* get the fingerprint */
    866 
    867   source.pipe   = sh_gpg_popen  ( &source, fd, 1,  sign_id, homedir);
    868   if (NULL == source.pipe)
    869     {
    870       sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
    871                       _("Could not open pipe for fp"),
    872                       _("gpg_check_file_sign"));
    873       SL_RETURN( SH_GPG_BAD, _("sh_gpg_check_file_sign"));
    874     }
    875 
    876   TPT(((0), FIL__, __LINE__, _("msg=<Open pipe success>\n")));
    877 
    878  yagain:
    879 
    880   errno = 0;
    881 
    882   while (NULL != fgets(line, sizeof(line), source.pipe))
    883     {
    884 #if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R)
    885       char * saveptr = NULL;
    886 #endif
    887       if (line[strlen(line)-1] == '\n')
    888         line[strlen(line)-1] = ' ';
    889       sh_error_handle(SH_ERR_ALL, FIL__, __LINE__, 0, MSG_E_SUBGEN,
    890                       line,
    891                       _("gpg_check_file_sign"));
    892 
    893       if (sl_strlen(line) < 18)
    894         continue;
    895 #if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R)
    896       ptr = strtok_r (line, " ", &saveptr);
    897 #else
    898       ptr = strtok (line, " ");
    899 #endif
    900       while (ptr)
    901         {
    902 #if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R)
    903           ptr = strtok_r (NULL, " ", &saveptr);
    904 #else
    905           ptr = strtok (NULL, " ");
    906 #endif
    907           if (ptr && 0 == sl_strncmp (ptr, _("fingerprint"), 11))
    908             {
    909 #if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R)
    910               ptr = strtok_r (NULL, " ", &saveptr); /* to '=' */
    911 #else
    912               ptr = strtok (NULL, " "); /* to '=' */
    913 #endif
    914               sign_fp[0] = '\0';
    915               while (ptr)
    916                 {
    917 #if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R)
    918                   ptr = strtok_r (NULL, " ", &saveptr); /* part of fingerprint */
    919 #else
    920                   ptr = strtok (NULL, " "); /* part of fingerprint */
    921 #endif
    922                   sl_strlcat (sign_fp, ptr, SH_MINIBUF+1);
    923                 }
    924               /* sign_fp[sl_strlen(sign_fp)-1] = '\0'; remove trailing '\n' */
    925               if (sl_strlen(sign_fp) > 0)
    926                 have_fp = GOOD;
    927               break;
    928             }
    929         }
    930     }
    931 
    932   if (ferror(source.pipe) && errno == EAGAIN)
    933     {
    934       retry_msleep(0,10); /* sleep 10 ms to avoid starving the gpg child writing to the pipe */
    935       clearerr(source.pipe);
    936       goto yagain;
    937     }
    938  
    939   sh_gpg_pclose (&source);
    940 #endif
    941 
    942738  if (have_id == GOOD)
    943739    {
    944740      TPT(((0), FIL__, __LINE__, _("msg=<Got signator ID>\n")));
    945       ;
    946741    }
    947742  if (have_fp == GOOD)
    948743    {
    949744      TPT(((0), FIL__, __LINE__, _("msg=<Got fingerprint>\n")));
    950       ;
    951745    }
    952746
    … …  
    969763int get_the_fd(SL_TICKET file_1);
    970764
    971 int sh_gpg_check_sign (long file_1, long file_2, int what)
     765#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && \
     766  defined(HAVE_GETPWNAM_R)
     767#define USE_GETPWNAM_R 1
     768#endif
     769
     770int sh_gpg_check_sign (long file, int what)
    972771{
    973772  int status = SH_GPG_BAD;
    974   int fd1 = 0;
    975   int fd2 = 0;
     773  int fd = 0;
     774
    976775  static int smsg = S_FALSE;
    977776  char  * tmp;
    978   char  * tmp2;
     777
     778  char  * sig_id;
     779  char  * sig_fp;
    979780
    980781  char  * homedir = sh.effective.home;
    981782#if defined(SH_WITH_SERVER)
    982783  struct passwd * tempres;
    983 #if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     784#if defined(USE_GETPWNAM_R)
    984785  struct passwd    pwd;
    985786  char           * buffer = SH_ALLOC(SH_PWBUF_SIZE);
    … …  
    994795
    995796
    996   if (what == 0 || what == 1)
    997     fd1 = get_the_fd(file_1);
    998   if (what == 0 || what == 2)
    999     fd2 = get_the_fd(file_2);
    1000 
    1001 
    1002   if (fd1 < 0 || fd2 < 0)
    1003     {
    1004       TPT(((0), FIL__, __LINE__, _("msg=<GPG_CHECK: FD1 = %d>\n"), fd1));
    1005       TPT(((0), FIL__, __LINE__, _("msg=<GPG_CHECK: FD2 = %d>\n"), fd2));
     797  if (what == SIG_CONF)
     798    fd = get_the_fd(file);
     799  if (what == SIG_DATA)
     800    fd = get_the_fd(file);
     801
     802
     803  if (fd < 0)
     804    {
     805      TPT(((0), FIL__, __LINE__, _("msg=<GPG_CHECK: FD = %d>\n"), fd));
    1006806      dlog(1, FIL__, __LINE__,
    1007807           _("This looks like an unexpected internal error.\n"));
    1008       sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_EXIT_ABORT1, sh.prg_name);
    1009       aud_exit (FIL__, __LINE__, EXIT_FAILURE);
     808#if defined(SH_WITH_SERVER) && defined(USE_GETPWNAM_R)
     809      SH_FREE(buffer);
     810#endif
     811      SL_RETURN( (-1), _("sh_gpg_check_sign"));
     812    }
     813 
    1010814#if defined(SH_WITH_SERVER)
    1011 #if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    1012       SH_FREE(buffer);
    1013 #endif
    1014 #endif
    1015       SL_RETURN( (-1), _("sh_gpg_check_sign"));
    1016     }
    1017  
    1018   if (what == 0 || what == 1)
    1019     {
    1020       TPT(((0), FIL__, __LINE__, _("msg=<GPG_CHECK: FD1 = %d>\n"), fd1));
    1021 #if defined(SH_WITH_SERVER)
    1022 #if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     815#if defined(USE_GETPWNAM_R)
    1023816      sh_getpwnam_r(DEFAULT_IDENT, &pwd, buffer, SH_PWBUF_SIZE, &tempres);
    1024817#else
    1025818      tempres = sh_getpwnam(DEFAULT_IDENT);
    1026819#endif
    1027 
    1028820      if ((tempres != NULL) && (0 == sl_ret_euid()))
    1029821        {
    … …  
    1032824        }
    1033825#endif
    1034       status = sh_gpg_check_file_sign(fd1, gp.conf_id, gp.conf_fp, homedir, 1);
     826
     827  if (what == SIG_CONF)
     828    {
     829      TPT(((0), FIL__, __LINE__, _("msg=<GPG_CHECK: FD = %d>\n"), fd));
     830      status = sh_gpg_check_file_sign(fd, gp.conf_id, gp.conf_fp, homedir, 1);
    1035831      TPT(((0), FIL__, __LINE__, _("msg=<CONF SIGUSR: |%s|>\n"), gp.conf_id));
    1036832      TPT(((0), FIL__, __LINE__, _("msg=<CONF SIGFP:  |%s|>\n"), gp.conf_fp));
    1037     }
    1038 
    1039   if ((what == 0 && SH_GPG_OK == status) || what == 2)
    1040     {
    1041       TPT(((0), FIL__, __LINE__, _("msg=<GPG_CHECK: FD2 = %d>\n"), fd2));
    1042 #if defined(SH_WITH_SERVER)
    1043 #if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    1044       sh_getpwnam_r(DEFAULT_IDENT, &pwd, buffer, SH_PWBUF_SIZE, &tempres);
    1045 #else
    1046       tempres = sh_getpwnam(DEFAULT_IDENT);
    1047 #endif
    1048 
    1049       if ((tempres != NULL) && (0 == sl_ret_euid()))
    1050         {
    1051           /* privileges not dropped yet*/
    1052           homedir = tempres->pw_dir;
    1053         }
    1054 #endif
    1055       status = sh_gpg_check_file_sign(fd2, gp.data_id, gp.data_fp, homedir, 2);
     833      sig_id =  gp.conf_id; sig_fp = gp.conf_fp;
     834    }
     835
     836  if (what == SIG_DATA)
     837    {
     838      TPT(((0), FIL__, __LINE__, _("msg=<GPG_CHECK: FD = %d>\n"), fd));
     839      status = sh_gpg_check_file_sign(fd, gp.data_id, gp.data_fp, homedir, 2);
    1056840      TPT(((0), FIL__, __LINE__, _("msg=<DATA SIGUSR: |%s|>\n"), gp.data_id));
    1057841      TPT(((0), FIL__, __LINE__, _("msg=<DATA SIGFP:  |%s|>\n"), gp.data_fp));
     842      sig_id =  gp.data_id; sig_fp = gp.data_fp;
    1058843    }
    1059844 
    1060   if (SH_GPG_OK == status && what == 1)
     845  if (SH_GPG_OK == status)
    1061846    {
    1062847#ifdef USE_FINGERPRINT
    1063       if ((sl_strcmp(SH_GPG_FP, gp.conf_fp) == 0))
     848      if ((sl_strcmp(SH_GPG_FP, sig_fp) == 0))
    1064849        {
    1065850          int i;
    1066851
    1067           for(i = 0; i < (int) sl_strlen(gp.conf_fp); ++i)
    1068             {
    1069               if (gpgfp[i] != gp.conf_fp[i])
    1070                 {
    1071                   sh_error_handle(SH_ERR_SEVERE, FIL__, __LINE__, 0,
    1072                                   MSG_E_GPG_FP,
    1073                                   gpgfp, gp.conf_fp);
    1074                   break;
    1075                 }
    1076             }
    1077 
    1078           if (smsg == S_FALSE)
    1079             {
    1080               tmp  = sh_util_safe_name(gp.conf_id);
    1081               sh_gpg_fill_startup (__LINE__,
    1082                                    /* sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_START_GH, */
     852          for(i = 0; i < (int) sl_strlen(sig_fp); ++i) {
     853              if (gpgfp[i] != sig_fp[i]) {
     854                sh_error_handle(SH_ERR_SEVERE, FIL__, __LINE__, 0,
     855                                MSG_E_GPG_FP, gpgfp, sig_fp);
     856                break; }
     857          }
     858
     859          if (smsg == S_FALSE) {
     860            tmp  = sh_util_safe_name(sig_id);
     861            sh_gpg_fill_startup (__LINE__, sh.prg_name, sh.real.uid,
     862                                 (sh.flag.hidefile == S_TRUE) ?
     863                                 _("(hidden)") : file_path('C', 'R'),
     864                                 tmp,
     865                                 sig_fp);
     866            SH_FREE(tmp); }
     867          smsg = S_TRUE;
     868
     869#if defined(SH_WITH_SERVER) && defined(USE_GETPWNAM_R)
     870          SH_FREE(buffer);
     871#endif
     872          SL_RETURN(0, _("sh_gpg_check_sign"));
     873        }
     874      else
     875        {
     876          /* fp mismatch */
     877          dlog(1, FIL__, __LINE__,
     878               _("The fingerprint of the signing key: %s\ndoes not match the compiled-in fingerprint: %s.\nTherefore the signature could not be verified.\n"),
     879               sig_fp, SH_GPG_FP);
     880          sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
     881                      _("Fingerprint mismatch"), _("gpg_check_sign"));
     882          status = SH_GPG_BADSIGN;
     883        }
     884#else /* ifdef USE_FINGERPRINT */
     885      if (smsg == S_FALSE)
     886        {
     887          tmp = sh_util_safe_name(sig_id);
     888          sh_gpg_fill_startup (__LINE__,
    1083889                               sh.prg_name, sh.real.uid,
    1084890                               (sh.flag.hidefile == S_TRUE) ?
    1085891                               _("(hidden)") : file_path('C', 'R'),
    1086                                tmp,
    1087                                gp.conf_fp);
    1088               SH_FREE(tmp);
    1089             }
    1090           smsg = S_TRUE;
    1091 #if defined(SH_WITH_SERVER)
    1092 #if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    1093           SH_FREE(buffer);
    1094 #endif
    1095 #endif
    1096           SL_RETURN(0, _("sh_gpg_check_sign"));
    1097         }
    1098       else
    1099         {
    1100           /* fp mismatch
    1101            */
    1102           dlog(1, FIL__, __LINE__,
    1103                _("The fingerprint of the signing key: %s\ndoes not match the compiled-in fingerprint: %s.\nTherefore the signature could not be verified.\n"),
    1104                gp.conf_fp, SH_GPG_FP);
    1105           sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
    1106                       _("Fingerprint mismatch"),
    1107                       _("gpg_check_sign"));
    1108           status = SH_GPG_BADSIGN;
    1109         }
    1110 #else
    1111       if (smsg == S_FALSE)
    1112         {
    1113           tmp = sh_util_safe_name(gp.conf_id);
    1114           sh_gpg_fill_startup (__LINE__,
    1115           /* sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_START_GH, */
    1116                            sh.prg_name, sh.real.uid,
    1117                            (sh.flag.hidefile == S_TRUE) ?
    1118                            _("(hidden)") : file_path('C', 'R'),
    1119                            tmp,
    1120                            gp.conf_fp);
     892                               tmp,  sig_fp);
    1121893          SH_FREE(tmp);
    1122894        }
    1123895      smsg = S_TRUE;
    1124 #if defined(SH_WITH_SERVER)
    1125 #if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     896
     897#if defined(SH_WITH_SERVER) && defined(USE_GETPWNAM_R)
    1126898      SH_FREE(buffer);
    1127899#endif
    1128 #endif
     900
    1129901      SL_RETURN(0, _("sh_gpg_check_sign"));
    1130 #endif
    1131     }
    1132  
    1133   else if (SH_GPG_OK == status && (what == 2 || what == 0))
    1134     {
    1135       if ((sl_strcmp(gp.data_id, gp.conf_id) == 0) &&
    1136           (sl_strcmp(gp.data_fp, gp.conf_fp) == 0))
    1137         {
    1138 #if defined(SH_WITH_SERVER)
    1139 #if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    1140           SH_FREE(buffer);
    1141 #endif
    1142 #endif
    1143           SL_RETURN(0, _("sh_gpg_check_sign"));
    1144         }
    1145       else
    1146         {
    1147           /* ID or fp not equal
    1148            */
    1149           dlog(1, FIL__, __LINE__,
    1150                _("The fingerprint or ID of the signing key is not the same for the\nconfiguration file and the file signature database.\nTherefore the signature could not be verified.\n"));
    1151           tmp  = sh_util_safe_name (gp.conf_id);
    1152           tmp2 = sh_util_safe_name (gp.data_id);
    1153           sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_START_GH2,
    1154                            sh.prg_name, sh.real.uid,
    1155                            (sh.flag.hidefile == S_TRUE) ? _("(hidden)") : file_path('C', 'R'),
    1156                            tmp,  gp.conf_fp,
    1157                            (sh.flag.hidefile == S_TRUE) ? _("(hidden)") : file_path('D', 'R'),
    1158                            tmp2, gp.data_fp);
    1159           SH_FREE(tmp);
    1160           SH_FREE(tmp2);
    1161         }
     902#endif /* !ifdef USE_FINGERPRINT */
    1162903    }
    1163904
    … …  
    1168909
    1169910#if defined(SH_WITH_SERVER)
    1170 #if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     911#if defined(USE_GETPWNAM_R)
    1171912      struct passwd    e_pwd;
    1172913      char          *  e_buffer = SH_ALLOC(SH_PWBUF_SIZE);
    … …  
    1186927      dlog(1, FIL__, __LINE__,
    1187928           _("The signature of the configuration file or the file signature database\ncould not be verified. Possible reasons are:\n - gpg binary (%s) not found\n - invalid signature\n - the signature key is not in the private keyring of UID %d,\n - there is no keyring in %s/.gnupg, or\n - the file is not signed - did you move /filename.asc to /filename ?\nTo create a signed file, use (remove old signatures before):\n   gpg -a --clearsign --not-dash-escaped FILE\n   mv FILE.asc FILE\n"),
    1188 #if defined(WITH_GPG)
    1189929           DEFAULT_GPG_PATH,
    1190 #else
    1191            DEFAULT_PGP_PATH,
    1192 #endif
    1193930           (int) e_uid, e_home);
    1194931
    1195 #if defined(SH_WITH_SERVER)
    1196 #if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
     932#if defined(SH_WITH_SERVER) && defined(USE_GETPWNAM_R)
    1197933      SH_FREE(e_buffer);
    1198934#endif
    1199 #endif
    1200935    }
    1201936
    1202937  TPT(((0), FIL__, __LINE__, _("msg=<Status = %d>\n"), status));
    1203 
    1204   sh_error_handle((-1), FIL__, __LINE__, status, MSG_EXIT_ABORT1, sh.prg_name);
    1205   aud_exit (FIL__, __LINE__, EXIT_FAILURE);
    1206938
    1207939  return (-1); /* make compiler happy */
    … …  
    1223955   */
    1224956  fdTmp = open_tmp();
     957  if (SL_ISERROR(fdTmp))
     958    {
     959      dlog(1, FIL__, __LINE__, _("Error opening temporary file.\n"));
     960      sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
     961                      _("Error opening temporary file."),
     962                      _("sh_gpg_extract_signed"));
     963      return -1;
     964    }
    1225965
    1226966  fin_cp = fdopen(dup(get_the_fd(fd)), "rb");

  • trunk/src/sh_hash.c

    r474 r481  
    2020#include "config_xor.h"
    2121
    22 /* define this if you want version 1.3 style database file */
    23 /* #define OLD_BUG */
    24 
    25 /* make sure state changes of a file are always reported, even
    26  *  with reportonlyonce=true
    27  */
    28 /* #define REPLACE_OLD *//* moved to samhain.h */
    29 
    3022#include <stdlib.h>
    3123#include <string.h>
    … …  
    4840#endif
    4941
     42
    5043#if defined(SH_WITH_CLIENT) || defined(SH_STANDALONE)
    5144
     45#include "samhain.h"
     46#include "sh_utils.h"
     47#include "sh_unix.h"
     48#include "sh_dbIO_int.h"
     49#include "sh_dbIO.h"
    5250#include "sh_hash.h"
    53 #include "sh_utils.h"
    5451#include "sh_error.h"
    5552#include "sh_tiger.h"
    … …  
    6158
    6259#if defined(SH_WITH_CLIENT)
    63 #include "sh_forward.h"
     60#include "sh_xfer.h"
    6461#endif
    6562
    … …  
    7168#define FIL__  _("sh_hash.c")
    7269
    73 SH_MUTEX_STATIC(mutex_hash,PTHREAD_MUTEX_INITIALIZER);
    74 
    75 const char notalink[2] = { '-', '\0' };
     70SH_MUTEX_INIT(mutex_hash,PTHREAD_MUTEX_INITIALIZER);
    7671
    7772static char * all_items (file_type * theFile, char * fileHash, int is_new);
    7873
    79 #define QUOTE_CHAR '='
    80 
    81 char * unquote_string (const char * str, size_t len)
    82 {
    83   int    i = 0, t1, t2;
    84   char * tmp = NULL;
    85   size_t l2, j, k = 0;
    86 
    87   SL_ENTER(_("unquote_string"));
    88 
    89   if (str != NULL)
    90     {
    91       l2  = len - 2;
    92       tmp = SH_ALLOC(len + 1);
    93 
    94       for (j = 0; j <= len; ++j)
    95         {
    96           if (str[j] != QUOTE_CHAR)
    97             {
    98               tmp[k] = str[j];
    99             }
    100           else if (str[j] == QUOTE_CHAR && j < l2)
    101             {
    102               t1 = sh_util_hexchar(str[j+1]);
    103               t2 = sh_util_hexchar(str[j+2]);
    104               if ((t1|t2) >= 0)
    105                 {
    106                   i = 16 * t1 + t2;
    107                   tmp[k] = i;
    108                   j += 2;
    109                 }
    110               else
    111                 {
    112                   tmp[k] = str[j];
    113                 }
    114             }
    115           else
    116             tmp[k] = str[j];
    117           ++k;
    118         }
    119     }
    120   SL_RETURN(tmp, _("unquote_string"));
    121 }
    122 
    123 
    124 static char * int2hex (unsigned char i, char * i2h)
    125 {
    126   static char hexchars[] = "0123456789ABCDEF";
    127 
    128   i2h[0] = hexchars[(((i) & 0xF0) >> 4)]; /* high */
    129   i2h[1] = hexchars[((i) & 0x0F)];        /* low  */
    130 
    131   return i2h;
    132 }
    133 
    134 
    135 char * quote_string (const char * str, size_t len)
    136 {
    137   char * tmp;
    138   char * tmp2;
    139   size_t l2, j, i = 0, k = 0;
    140   char   i2h[2];
    141 
    142   SL_ENTER(_("quote_string"));
    143 
    144   if (str == NULL)
    145     {
    146       SL_RETURN(NULL, _("quote_string"));
    147     }
    148 
    149   for (j = 0; j < len; ++j)
    150     if (str[j] == '\n' || str[j] == QUOTE_CHAR) ++i;
    151 
    152   l2 = len + 1;
    153   if (sl_ok_muls(3, i) && sl_ok_adds(l2, (3*i)))
    154     {
    155       tmp = SH_ALLOC(len + 1 + 3*i);
    156     }
    157   else
    158     {
    159       sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    160                       _("integer overflow"),
    161                       _("quote_string"));
    162       SL_RETURN(NULL, _("quote_string"));
    163     }
    164 
    165   for (j = 0; j <= len; ++j)
    166     {
    167       if (str[j] == '\n')
    168         {
    169           tmp2 = int2hex((unsigned char) '\n', i2h); /* was 'n', fixed in 1.5.4 */
    170           tmp[k] = QUOTE_CHAR; ++k;
    171           tmp[k] = tmp2[0];    ++k;
    172           tmp[k] = tmp2[1];
    173         }
    174       else if (str[j] == QUOTE_CHAR)
    175         {
    176           tmp2 = int2hex((unsigned char) QUOTE_CHAR, i2h);
    177           tmp[k] = QUOTE_CHAR; ++k;
    178           tmp[k] = tmp2[0];    ++k;
    179           tmp[k] = tmp2[1];
    180         }
    181       else
    182         {
    183           tmp[k] = str[j];
    184         }
    185       ++k;
    186     }
    187   SL_RETURN(tmp, _("quote_string"));
    188 }
    189 
    190 static UINT32 * swap_32 (UINT32 * iptr)
    191 {
    192 #ifdef WORDS_BIGENDIAN
    193   unsigned char swap;
    194   unsigned char * ii = (unsigned char *) iptr;
    195   swap = ii[0]; ii[0] = ii[3]; ii[3] = swap;
    196   swap = ii[1]; ii[1] = ii[2]; ii[2] = swap;
    197   return iptr;
    198 #else
    199   return iptr;
    200 #endif
    201 }
    202 
    203 static UINT64 *  swap_64 (UINT64 * iptr)
    204 {
    205 #ifdef WORDS_BIGENDIAN
    206 #ifdef UINT64_IS_32
    207   swap_32 ((UINT32*) iptr);
    208 #else
    209   unsigned char swap;
    210   unsigned char * ii = (unsigned char *) iptr;
    211   swap = ii[0]; ii[0] = ii[7]; ii[7] = swap;
    212   swap = ii[1]; ii[1] = ii[6]; ii[6] = swap;
    213   swap = ii[2]; ii[2] = ii[5]; ii[5] = swap;
    214   swap = ii[3]; ii[3] = ii[4]; ii[4] = swap;
    215 #endif
    216   return iptr;
    217 #else
    218   return iptr;
    219 #endif
    220 }
    221 
    222 static unsigned short *  swap_short (unsigned short * iptr)
    223 {
    224 #ifdef WORDS_BIGENDIAN
    225   if (sizeof(short) == 4)
    226     swap_32 ((UINT32*) iptr);
    227   else
    228     {
    229       /* alignment problem */
    230       unsigned char swap;
    231       static unsigned short ooop;
    232       unsigned char * ii;
    233       ooop = *iptr;
    234       ii = (unsigned char *) &ooop;
    235       /* printf("SWAP0: %hd  %d\n", *iptr, sizeof(unsigned short)); */
    236       swap = ii[0]; ii[0] = ii[1]; ii[1] = swap;
    237       /* printf("SWAP1: %hd\n", (unsigned short) ooop); */
    238 #ifndef OLD_BUG
    239       return &ooop;
    240 #endif
    241     }
    242   return iptr;
    243 #else
    244   return iptr;
    245 #endif
    246 }
    247 
    248 
    249 typedef struct store_info {
    250 
    251   UINT32           mode;
    252   UINT32           linkmode;
    253 
    254   UINT64           dev;
    255   UINT64           rdev;
    256   UINT32           hardlinks;
    257   UINT32           ino;
    258   UINT64           size;
    259   UINT64           atime;
    260   UINT64           mtime;
    261   UINT64           ctime;
    262   UINT32           owner;
    263   UINT32           group;
    264 
    265 #ifdef OLD_BUG
    266 #if defined(__linux__)
    267   UINT32           attributes;
    268   char             c_attributes[ATTRBUF_SIZE];
    269 #endif
    270 #else
    271   /* #if defined(__linux__) */
    272   UINT32           attributes;
    273   char             c_attributes[ATTRBUF_SIZE];
    274   /* endif                  */
    275 #endif
    276   unsigned short   mark;
    277   char             c_owner[USER_MAX+2];
    278   char             c_group[GROUP_MAX+2];
    279   char             c_mode[CMODE_SIZE];
    280   char             checksum[KEY_LEN+1];
    281 } sh_filestore_t;
    282  
    283 typedef struct file_info {
    284   sh_filestore_t   theFile;
    285   char           * fullpath;
    286   char           * linkpath;
    287   char           * attr_string;
    288   int              fflags;
    289   unsigned long    modi_mask;
    290   struct           file_info * next;
    291 } sh_file_t;
    292 
    293   static const char  *policy[] = {
    294     N_("[]"),
    295     N_("[ReadOnly]"),
    296     N_("[LogFiles]"),
    297     N_("[GrowingLogs]"),
    298     N_("[IgnoreNone]"),
    299     N_("[IgnoreAll]"),
    300     N_("[Attributes]"),
    301     N_("[User0]"),
    302     N_("[User1]"),
    303     N_("[User2]"),
    304     N_("[User3]"),
    305     N_("[User4]"),
    306     N_("[Prelink]"),
    307     NULL
    308   };
     74static const char  *policy[] = {
     75  N_("[]"),
     76  N_("[ReadOnly]"),
     77  N_("[LogFiles]"),
     78  N_("[GrowingLogs]"),
     79  N_("[IgnoreNone]"),
     80  N_("[IgnoreAll]"),
     81  N_("[Attributes]"),
     82  N_("[User0]"),
     83  N_("[User1]"),
     84  N_("[User2]"),
     85  N_("[User3]"),
     86  N_("[User4]"),
     87  N_("[Prelink]"),
     88  NULL
     89};
     90
     91static int report_checkflags = S_FALSE;
     92int set_report_checkflags(const char * c)
     93{
     94  return sh_util_flagval(c, &report_checkflags);
     95}
     96int get_report_checkflags()
     97{
     98  return report_checkflags;
     99}
     100
     101
    309102
    310103const char * sh_hash_getpolicy(int class)
    … …  
    324117#include "sh_hash.h"
    325118
    326 /* must fit an int              */
    327 /* #define TABSIZE 2048         */
    328 #define TABSIZE 65536
    329 
    330 /* must fit an unsigned short   */
    331 /* changed for V0.8, as the     */
    332 /* database format has changed  */
    333 
    334 /* changed again for V0.9       */
    335 /* #define REC_MAGIC 19         */
    336 /* changed again for V1.3       */
    337 #ifdef OLD_BUG
    338 #define REC_MAGIC 20
    339 #else
    340 /* changed again for V1.4       */
    341 #define REC_MAGIC 21
    342 #endif
    343 
    344 #define REC_FLAGS_ATTR (1<<8)
    345 #define REC_FLAGS_MASK 0xFF00
    346119
    347120/**************************************************************
    … …  
    350123 *
    351124 **************************************************************/
    352 static file_type * sh_hash_create_ft (const sh_file_t * p, char * fileHash)
     125file_type * sh_hash_create_ft (const sh_file_t * p, char * fileHash)
    353126{
    354127  file_type * theFile;
    … …  
    391164  theFile->dev   =  p->theFile.dev;
    392165  theFile->hardlinks = p->theFile.hardlinks;
     166  theFile->check_flags = p->theFile.checkflags;
    393167
    394168  if (p->attr_string)
    … …  
    408182static int hashsearch_prev (const char * s, struct two_sh_file_t * a, int * index);
    409183
     184
     185/**************************************************************
     186 *
     187 * >>>> The internal database <<<
     188 *
     189 **************************************************************/
     190
    410191static sh_file_t * tab[TABSIZE];
     192
     193sh_file_t ** get_default_data_table()
     194{
     195  return tab;
     196}
    411197
    412198/**************************************************************
    … …  
    499285  if (p->linkpath)
    500286    {
    501       if (p->linkpath != notalink)
    502         SH_FREE(p->linkpath);
     287      SH_FREE(p->linkpath);
    503288      p->linkpath = NULL;
    504289    }
    … …  
    521306  char   fileHash[KEY_LEN + 1];
    522307  file_type * theFile;
    523 
    524308  char * str;
    525 
    526309
    527310  SL_ENTER(_("hash_unvisited"));
    … …  
    552335  if (((!SH_FFLAG_VISITED_SET(p->fflags)) || SH_FFLAG_CHECKED_SET(p->fflags))
    553336      && (!SH_FFLAG_REPORTED_SET(p->fflags))
    554       && (!SH_FFLAG_ALLIGNORE_SET(p->fflags)))
     337      /* && (!SH_FFLAG_ALLIGNORE_SET(p->fflags)) */)
    555338    {
    556339      i = retry_lstat(FIL__, __LINE__, p->fullpath, &buf);
    … …  
    565348              /* If any of the parent directories is under IgnoreAll
    566349               */
    567               if (0 != sh_files_is_allignore(ptr))
     350              if ((0 != sh_files_is_allignore(ptr)) || SH_FFLAG_ALLIGNORE_SET(p->fflags))
    568351                level = ShDFLevel[SH_LEVEL_ALLIGNORE];
    569352              SH_FREE(ptr);
    … …  
    599382              (S_TRUE == sh.flag.update && S_TRUE == sh_util_ask_update(p->fullpath)))
    600383            {
    601 #ifdef REPLACE_OLD
    602384              /* Remove the old entry
    603385               */
    … …  
    610392
    611393              SL_RET0(_("hash_unvisited"));
    612 #else
    613               SET_SH_FFLAG_REPORTED(p->fflags);
    614 #endif
    615394            }
    616395        }
    … …  
    679458 *
    680459 *********************************************************************/
    681 void sh_hash_remove (const char * path)
     460void sh_hash_remove_unconditional (const char * path)
    682461{
    683462  struct two_sh_file_t entries;
    684463  int index;
    685464
     465  SL_ENTER(_("sh_hash_remove_unconditional"));
     466
     467  SH_MUTEX_LOCK(mutex_hash);
     468  if (0 == hashsearch_prev (path, &entries, &index))
     469    {
     470      sh_file_t * p = entries.this;
     471     
     472      /* Remove the old entry
     473       */
     474      if (entries.prev == p)
     475        tab[index] = p->next;
     476      else
     477        entries.prev->next = p->next;
     478     
     479      delete_db_entry(p);
     480    }
     481  SH_MUTEX_UNLOCK(mutex_hash);
     482
     483  SL_RET0(_("sh_hash_remove_unconditional"));
     484}
     485
     486void sh_hash_remove (const char * path)
     487{
    686488  SL_ENTER(_("sh_hash_remove"));
    687 
    688   SH_MUTEX_LOCK(mutex_hash);
    689489
    690490  if ((sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE) ||
    691491      (S_TRUE == sh.flag.update && S_TRUE == sh_util_ask_update(path)))
    692492    {
    693       if (0 == hashsearch_prev (path, &entries, &index))
    694         {
    695           sh_file_t * p = entries.this;
    696 #ifdef REPLACE_OLD
    697           /* Remove the old entry
    698            */
    699           if (entries.prev == p)
    700             tab[index] = p->next;
    701           else
    702             entries.prev->next = p->next;
    703          
    704           delete_db_entry(p);
    705          
    706           goto end;
    707 #else
    708           SET_SH_FFLAG_REPORTED(p->fflags);
    709 #endif
    710         }
    711     }
    712 
    713  end:
    714   ; /* 'label at end of compound statement' */
    715   SH_MUTEX_UNLOCK(mutex_hash);
    716 
     493      sh_hash_remove_unconditional (path);
     494    }
    717495  SL_RET0(_("sh_hash_remove"));
    718496}
    … …  
    811589  if (p->linkpath)
    812590    {
    813       if (p->linkpath != notalink)
    814         SH_FREE(p->linkpath);
     591      SH_FREE(p->linkpath);
    815592      p->linkpath = NULL;
    816593    }
    … …  
    856633    {
    857634      *index = hashfunc(s);
    858 
    859       this = tab[*index];
    860 
    861       prev  = this;
     635      this   = tab[*index];
     636      prev   = this;
    862637
    863638      if (this)
    864639        {
    865640          do {
    866            
    867641            if ((this->fullpath != NULL) && (0 == strcmp(s, this->fullpath)))
    868642              {
    869643                a->prev = prev;
    870                 a->this = this;
    871                
     644                a->this = this;
    872645                SL_RETURN( 0, _("hashsearch_prev"));
    873646              }
    874            
    875647            prev = this;
    876648            this = this->next;
    877            
    878649          } while(this);
    879650        }
    … …  
    888659 *
    889660 ***********************************************************************/
    890 static void hashinsert (sh_file_t * s)
     661void hashinsert (sh_file_t * mtab[TABSIZE], sh_file_t * s)
    891662{
    892663  sh_file_t * p;
    … …  
    898669  key = hashfunc(s->fullpath);
    899670
    900   if (tab[key] == NULL)
    901     {
    902       tab[key] = s;
    903       tab[key]->next = NULL;
     671  if (mtab[key] == NULL)
     672    {
     673      mtab[key] = s;
     674      mtab[key]->next = NULL;
    904675      SL_RET0(_("hashinsert"));
    905676    }
    906677  else
    907678    {
    908       p = tab[key];
     679      p = mtab[key];
    909680      while (1)
    910681        {
    911           if (p && p->fullpath &&
    912               0 == strcmp(s->fullpath, p->fullpath))
     682          if (p && p->fullpath && 0 == strcmp(s->fullpath, p->fullpath))
    913683            {
    914684              q = p->next;
    915685              SH_FREE(p->fullpath);
    916               if(p->linkpath && p->linkpath != notalink)
    917                 SH_FREE(p->linkpath);
    918               if(p->attr_string)
    919                 SH_FREE(p->attr_string);
     686              if(p->linkpath)    SH_FREE(p->linkpath);
     687              if(p->attr_string) SH_FREE(p->attr_string);
    920688              memcpy(p, s, sizeof(sh_file_t));
    921689              p->next = q;
    922               SH_FREE(s);
    923               s = NULL;
     690              SH_FREE(s); s = NULL;
    924691              SL_RET0(_("hashinsert"));
    925692            }
    … …  
    940707
    941708
     709
    942710/******************************************************************
    943711 *
    944  * Get a single line
     712 * ------- Check functions -------
    945713 *
    946714 ******************************************************************/
    947 static FILE * sh_fin_fd = NULL;
    948 
    949 static int sh_hash_getline (FILE * fd, char * line, int sizeofline)
    950 {
    951   register int  n = 0;
    952   char        * res;
    953 
    954   if (sizeofline < 2) {
    955     if (sizeofline > 0) line[0] = '\0';
    956     return 0;
    957   }
    958   res = fgets(line, sizeofline, fd);
    959   if (res == NULL)
    960     {
    961       line[0] = '\0';
    962       return -1;
    963     }
    964   n = strlen(line);
    965   if (n > 0) {
    966     --n;
    967     line[n] = '\0'; /* remove terminating '\n' */
    968   }
    969   return n;
    970 }
    971 
    972 static void sh_hash_getline_end (void)
    973 {
    974   sl_fclose (FIL__, __LINE__, sh_fin_fd);
    975   sh_fin_fd = NULL;
     715
     716static int IsInit = 0;
     717
     718void sh_hash_set_initialized()
     719{
     720  IsInit = 1;
    976721  return;
    977722}
    978723
    979 /******************************************************************
    980  *
    981  * ------- Check functions -------
    982  *
    983  ******************************************************************/
    984 
    985 static int IsInit = 0;
    986 
    987 
    988 /******************************************************************
    989  *
    990  * Fast forward to start of data
    991  *
    992  ******************************************************************/
    993 int sh_hash_setdataent (SL_TICKET fd, char * line, int size, const char * file)
    994 {
    995   long i;
    996   extern int get_the_fd (SL_TICKET ticket);
    997 
    998   SL_ENTER(_("sh_hash_setdataent"));
    999 
    1000   sl_rewind (fd);
    1001 
    1002   if (sh_fin_fd != NULL)
    1003     {
    1004       sl_fclose (FIL__, __LINE__, sh_fin_fd);
    1005       sh_fin_fd = NULL;
    1006     }
    1007 
    1008   sh_fin_fd = fdopen(dup(get_the_fd(fd)), "rb");
    1009   if (!sh_fin_fd)
    1010     {
    1011       dlog(1, FIL__, __LINE__,
    1012            _("The file signature database: %s is not readable.\n"),
    1013            (NULL == file) ? _("(null)") : file);
    1014       sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_P_NODATA,
    1015                        ( (NULL == file) ? _("(null)") : file)
    1016                        );
    1017       aud_exit (FIL__, __LINE__, EXIT_FAILURE);
    1018     }
    1019 
    1020   while (1)
    1021     {
    1022       i =  sh_hash_getline (sh_fin_fd, line, size);
    1023       if (i < 0 )
    1024         {
    1025           SH_FREE(line);
    1026           dlog(1, FIL__, __LINE__,
    1027                _("The file signature database: %s does not\ncontain any data, or the start-of-file marker is missing (unlikely,\nunless modified by hand).\n"),
    1028                (NULL == file) ? _("(null)") : file);
    1029                
    1030           sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_P_NODATA,
    1031                            ( (NULL == file) ? _("(null)") : file)
    1032                            );
    1033           aud_exit (FIL__, __LINE__, EXIT_FAILURE);
    1034         }
    1035 
    1036 #if defined(SH_STEALTH)
    1037       if (0 == sl_strncmp (line, N_("[SOF]"), 5))
    1038 #else
    1039       if (0 == sl_strncmp (line, _("[SOF]"),  5))
    1040 #endif
    1041         break;
    1042     }
    1043   SL_RETURN( 1, _("sh_hash_setdataent"));
    1044 }
    1045 
    1046 static int sh_hash_setdataent_old (SL_TICKET fd, char * line, int size,
    1047                                    char * file)
    1048 {
    1049   long i;
    1050 
    1051   SL_ENTER(_("sh_hash_setdataent_old"));
    1052 
    1053   sl_rewind (fd);
    1054 
    1055   while (1)
    1056     {
    1057       i =  sh_unix_getline (fd, line, size-1);
    1058       if (i < 0 )
    1059         {
    1060           SH_FREE(line);
    1061           dlog(1, FIL__, __LINE__,
    1062                _("The file signature database: %s does not\ncontain any data, or the start-of-file marker is missing (unlikely,\nunless modified by hand).\n"),
    1063                (NULL == file) ? _("(null)") : file);
    1064                
    1065           sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_P_NODATA,
    1066                            ( (NULL == file) ? _("(null)") : file)
    1067                            );
    1068           aud_exit (FIL__, __LINE__, EXIT_FAILURE);
    1069         }
    1070 
    1071 #if defined(SH_STEALTH)
    1072       if (0 == sl_strncmp (line, N_("[SOF]"), 5))
    1073 #else
    1074       if (0 == sl_strncmp (line, _("[SOF]"),  5))
    1075 #endif
    1076         break;
    1077     }
    1078   SL_RETURN( 1, _("sh_hash_setdataent_old"));
    1079 }
    1080 
    1081 /******************************************************************
    1082  *
    1083  * Read next record
    1084  *
    1085  ******************************************************************/
    1086 sh_file_t *  sh_hash_getdataent (SL_TICKET fd, char * line, int size)
    1087 {
    1088   sh_file_t * p;
    1089   sh_filestore_t ft;
    1090   long i;
    1091   size_t len;
    1092   char * fullpath;
    1093   char * linkpath;
    1094   char * attr_string = NULL;
    1095   char * tmp;
    1096 
    1097   SL_ENTER(_("sh_hash_getdataent"));
    1098 
    1099   (void) fd;
    1100 
    1101   /* Read next record -- Part One
    1102    */
    1103   p = SH_ALLOC(sizeof(sh_file_t));
    1104 
    1105   i = fread (&ft, sizeof(sh_filestore_t), 1, sh_fin_fd);
    1106   /* i = sl_read(fd, &ft, sizeof(sh_filestore_t)); */
    1107   /* if ( SL_ISERROR(i) || i == 0) */
    1108   if (i < 1)
    1109     {
    1110       SH_FREE(p);
    1111       SL_RETURN( NULL, _("sh_hash_getdataent"));
    1112     }
    1113 
    1114   swap_32(&(ft.mode));
    1115   swap_32(&(ft.linkmode));
    1116   swap_64(&(ft.dev));
    1117   swap_64(&(ft.rdev));
    1118   swap_32(&(ft.hardlinks));
    1119   swap_32(&(ft.ino));
    1120   swap_64(&(ft.size));
    1121   swap_64(&(ft.atime));
    1122   swap_64(&(ft.mtime));
    1123   swap_64(&(ft.ctime));
    1124   swap_32(&(ft.owner));
    1125   swap_32(&(ft.group));
    1126 #if defined(__linux__) || defined(HAVE_STAT_FLAGS)
    1127   swap_32(&(ft.attributes));
    1128 #endif
    1129 #ifdef OLD_BUG
    1130   swap_short(&(ft.mark));
    1131 #else
    1132   ft.mark = *(swap_short(&(ft.mark)));
    1133 #endif
    1134 
    1135   if ((ft.mark & ~REC_FLAGS_MASK) != REC_MAGIC)
    1136     {
    1137       SH_FREE(p);
    1138       SL_RETURN( NULL, _("sh_hash_getdataent"));
    1139     }
    1140 
    1141   /* Read next record -- Part Two -- Fullpath
    1142    */
    1143   i =  sh_hash_getline (sh_fin_fd, line, size);
    1144   if (i <= 0 )
    1145     {
    1146       SH_FREE(line);
    1147       SH_FREE(p);
    1148       dlog(1, FIL__, __LINE__,
    1149            _("There is a corrupt record in the file signature database: %s\nThe file path is missing.\n"),
    1150            (NULL == file_path('D', 'R'))? _("(null)"):file_path('D', 'R'));
    1151       sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_P_NODATA,
    1152                            ( (NULL == file_path('D', 'R')) ? _("(null)") :
    1153                              file_path('D', 'R'))
    1154                             );
    1155       aud_exit (FIL__, __LINE__,EXIT_FAILURE);
    1156     }
    1157 
    1158   tmp = unquote_string (line, i);
    1159   len = sl_strlen(tmp)+1;
    1160   fullpath = SH_ALLOC(len);
    1161   (void) sl_strlcpy (fullpath, tmp, len);
    1162   if (tmp)
    1163     SH_FREE(tmp);
    1164   if (fullpath[len-2] == '\n')
    1165     fullpath[len-2] = '\0';
    1166 
    1167   /* Read next record -- Part Three -- Linkpath
    1168    */
    1169   i =  sh_hash_getline (sh_fin_fd, line, size);
    1170   if (i <= 0 )
    1171     {
    1172       SH_FREE(line);
    1173       SH_FREE(fullpath);
    1174       SH_FREE(p);
    1175       dlog(1, FIL__, __LINE__,
    1176            _("There is a corrupt record in the file signature database: %s\nThe link path (or its placeholder) is missing.\n"),
    1177            (NULL == file_path('D', 'R'))? _("(null)"):file_path('D', 'R'));
    1178       sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_P_NODATA,
    1179                        ( (NULL == file_path('D', 'R')) ? _("(null)") :
    1180                          file_path('D', 'R'))
    1181                        );
    1182       aud_exit (FIL__, __LINE__,EXIT_FAILURE);
    1183     }
    1184 
    1185   tmp = unquote_string (line, i);
    1186 
    1187   if ( tmp && tmp[0] == '-' &&
    1188        (tmp[1] == '\0' || (tmp[1] == '\n' && tmp[2] == '\0')))
    1189     {
    1190       linkpath = (char *)notalink;
    1191     }
    1192   else
    1193     {
    1194       len = sl_strlen(tmp);
    1195       linkpath = sh_util_strdup_l(tmp, len);
    1196       if (len > 0 && linkpath[len-1] == '\n')
    1197         linkpath[len-1] = '\0';
    1198     }
    1199 
    1200   if (tmp)
    1201     SH_FREE(tmp);
    1202 
    1203   /* Read next record -- Part Four -- attr_string
    1204    */
    1205   if ((ft.mark & REC_FLAGS_ATTR) != 0)
    1206     {
    1207       i =  sh_hash_getline (sh_fin_fd, line, size);
    1208       if (i <= 0 )
    1209         {
    1210           SH_FREE(line);
    1211           SH_FREE(fullpath);
    1212           if (linkpath != notalink)
    1213             SH_FREE(linkpath);
    1214           SH_FREE(p);
    1215           dlog(1, FIL__, __LINE__,
    1216                _("There is a corrupt record in the file signature database: %s\nThe attribute string is missing.\n"),
    1217                (NULL == file_path('D', 'R'))? _("(null)"):file_path('D', 'R'));
    1218           sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_P_NODATA,
    1219                            ( (NULL == file_path('D', 'R')) ? _("(null)") :
    1220                              file_path('D', 'R'))
    1221                            );
    1222           aud_exit (FIL__, __LINE__,EXIT_FAILURE);
    1223         }
    1224 
    1225       tmp = unquote_string (line, i);
    1226 
    1227       len = sl_strlen(tmp)+1;
    1228       attr_string = SH_ALLOC(len);
    1229       (void) sl_strlcpy (attr_string, tmp, len);
    1230       if (tmp)
    1231         SH_FREE(tmp);
    1232       if (attr_string[len-2] == '\n')
    1233         attr_string[len-2] = '\0';
    1234     }
    1235 
    1236   /* Read next record -- Part Four -- Decode
    1237    */
    1238 #if defined(SH_STEALTH)
    1239   sh_do_decode(fullpath,    sl_strlen(fullpath));
    1240  
    1241 #if defined(__linux__) || defined(HAVE_STAT_FLAGS)
    1242   sh_do_decode(ft.c_attributes,   sl_strlen(ft.c_attributes));
    1243 #endif
    1244  
    1245   sh_do_decode(ft.c_mode,   sl_strlen(ft.c_mode));
    1246   sh_do_decode(ft.c_owner,  sl_strlen(ft.c_owner));
    1247   sh_do_decode(ft.c_group,  sl_strlen(ft.c_group));
    1248   sh_do_decode(ft.checksum, sl_strlen(ft.checksum));
    1249  
    1250   /* TXT entries are c_mode[0] != 'l' and do not get decoded
    1251    */
    1252   if (ft.c_mode[0] == 'l' && linkpath != notalink)
    1253     { 
    1254       sh_do_decode(linkpath, sl_strlen(linkpath));
    1255     }
    1256 
    1257   if ((ft.mark & REC_FLAGS_ATTR) != 0)
    1258     { 
    1259       sh_do_decode(attr_string, sl_strlen(attr_string));
    1260     }
    1261 #endif
    1262 
    1263   memcpy( &(*p).theFile, &ft, sizeof(sh_filestore_t) );
    1264 
    1265   /* init fflags, such that suid files in
    1266    * database are recognized as such
    1267    */
    1268   {
    1269     mode_t mode = (mode_t) ft.mode;
    1270 
    1271     if (S_ISREG(mode) &&
    1272         (0 !=(S_ISUID & mode) ||
    1273 #if defined(HOST_IS_LINUX)
    1274          (0 !=(S_ISGID & mode) &&
    1275           0 !=(S_IXGRP & mode))
    1276 #else 
    1277          0 !=(S_ISGID & mode)
    1278 #endif
    1279          )
    1280         )
    1281       p->fflags = SH_FFLAG_SUIDCHK;
    1282 
    1283     else
    1284       p->fflags = 0;
    1285   }
    1286      
    1287   p->modi_mask = 0L;
    1288   p->fullpath  = fullpath;
    1289   p->linkpath  = linkpath;
    1290 
    1291   p->attr_string = attr_string;
    1292 
    1293   /* set to an invalid value
    1294    */
    1295   ft.mark = (REC_MAGIC + 5);
    1296 
    1297   SL_RETURN( p, _("sh_hash_getdataent"));
    1298 }
     724int sh_hash_get_initialized()
     725{
     726  return IsInit;
     727}
     728
    1299729
    1300730/******************************************************************
    … …  
    1305735void sh_hash_init ()
    1306736{
    1307 
    1308 #define FGETS_BUF 16384
    1309 
    1310   sh_file_t * p;
    1311   SL_TICKET fd;
    1312   long i;
    1313   int count = 0;
    1314   char * line = NULL;
    1315 
    1316 #if defined(WITH_GPG) || defined(WITH_PGP)
    1317   extern int get_the_fd (SL_TICKET ticket);
    1318 
    1319   SL_TICKET fdTmp = (-1);
    1320 #endif
    1321   char hashbuf[KEYBUF_SIZE];
    1322 
    1323737  volatile int  retval  = 0;
    1324738  volatile int  exitval = EXIT_SUCCESS;
    … …  
    1341755    }
    1342756
    1343   fd = (-1);
    1344 
    1345 #if defined(SH_WITH_CLIENT)
    1346 
    1347   /* Data file from Server
    1348    */
    1349 
    1350   if (fd == (-1) && 0 == sl_strcmp(file_path('D', 'R'), _("REQ_FROM_SERVER")))
    1351     {
    1352       sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_D_DSTART);
    1353       fd = sh_forward_req_file(_("DATA"));
    1354       if (SL_ISERROR(fd))
    1355         {
    1356           dlog(1, FIL__, __LINE__,
    1357                _("Could not retrieve the file signature database from the server(errnum = %ld).\nPossible reasons include:\n - the server is not running,\n - session key negotiation failed (see the manual for proper setup), or\n - the server cannot access the file.\n"), fd);
    1358           sh_error_handle ((-1), FIL__, __LINE__, fd, MSG_EXIT_ABORT1,
    1359                            sh.prg_name);
    1360           retval = 1; exitval = EXIT_FAILURE;
    1361           goto unlock_and_return;
    1362         }
    1363       sl_rewind (fd);
    1364 
    1365       sl_strlcpy (sh.data.hash,
    1366                   sh_tiger_hash (file_path('D', 'R'), 
    1367                                  fd, TIGER_NOLIM, hashbuf, sizeof(hashbuf)),
    1368                   KEY_LEN+1);
    1369       sl_rewind (fd);
    1370     }
    1371   else
    1372 #endif
    1373     /* Local data file
    1374      */
    1375 
    1376     if (fd == (-1))
    1377       {
    1378         if ( SL_ISERROR(fd = sl_open_read(FIL__, __LINE__,
    1379                                           file_path('D', 'R'), SL_YESPRIV)))
    1380           {
    1381             TPT(( 0, FIL__, __LINE__, _("msg=<Error opening: %s>\n"),
    1382                   file_path('D', 'R')));
    1383             dlog(1, FIL__, __LINE__,
    1384                  _("Could not open the local file signature database for reading because\nof the following error: %s (errnum = %ld)\nIf this is a permission problem, you need to change file permissions\nto make the file readable for the effective UID: %d\n"),
    1385                  sl_get_errmsg(), fd, (int) sl_ret_euid());
    1386             sh_error_handle ((-1), FIL__, __LINE__, fd, MSG_EXIT_ABORT1,
    1387                              sh.prg_name);
    1388             retval = 1; exitval = EXIT_FAILURE;
    1389             goto unlock_and_return;
    1390           }
    1391        
    1392         TPT(( 0, FIL__, __LINE__, _("msg=<Opened database: %s>\n"),
    1393               file_path('D', 'R')));
    1394 
    1395         if (0 != sl_strncmp(sh.data.hash,
    1396                             sh_tiger_hash (file_path('D', 'R'), fd, TIGER_NOLIM,
    1397                                            hashbuf, sizeof(hashbuf)),
    1398                             KEY_LEN)
    1399             && sh.flag.checkSum != SH_CHECK_INIT)
    1400           {
    1401             dlog(1, FIL__, __LINE__,
    1402                  _("The checksum of the file signature database has changed since startup: %s -> %s\n"),
    1403                  sh.data.hash, sh_tiger_hash (file_path('D', 'R'), fd, TIGER_NOLIM,
    1404                                            hashbuf, sizeof(hashbuf)));
    1405             sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_E_AUTH,
    1406                              ( (NULL == file_path('D', 'R')) ? _("(null)") :
    1407                                file_path('D', 'R') )
    1408                              );
    1409             retval = 1; exitval = EXIT_FAILURE;
    1410             goto unlock_and_return;
    1411           }
    1412         sl_rewind (fd);
    1413 
    1414       } /* new 1.4.8 */
    1415 
    1416   if (sig_termfast == 1)  /* SIGTERM */
    1417     {
    1418       TPT((0, FIL__, __LINE__, _("msg=<Terminate.>\n")));
    1419       --sig_raised; --sig_urgent;
    1420       retval = 1; exitval = EXIT_SUCCESS;
    1421       goto unlock_and_return;
    1422     }
    1423 
    1424 #if defined(WITH_GPG) || defined(WITH_PGP)
    1425 
    1426   /* extract the data and copy to temporary file
    1427    */
    1428   fdTmp = sh_gpg_extract_signed(fd);
    1429 
    1430   if (sig_termfast == 1)  /* SIGTERM */
    1431     {
    1432       TPT((0, FIL__, __LINE__, _("msg=<Terminate.>\n")));
    1433       --sig_raised; --sig_urgent;
    1434       retval = 1; exitval = EXIT_SUCCESS;
    1435       goto unlock_and_return;
    1436     }
    1437 
    1438   sl_close(fd);
    1439   fd = fdTmp;
    1440 
    1441   /* Validate signature of open file.
    1442    */
    1443   if (0 != sh_gpg_check_sign (0, fd, 2))
    1444     {
    1445       retval = 1; exitval = EXIT_FAILURE;
    1446       goto unlock_and_return;
    1447     }
    1448   sl_rewind (fd);
    1449 #endif
    1450 
    1451   line = SH_ALLOC(MAX_PATH_STORE+2);
    1452 
    1453   /* fast forward to start of data
    1454    */
    1455   sh_hash_setdataent(fd, line, MAX_PATH_STORE+1, file_path('D', 'R'));
    1456 
    1457   for (i = 0; i < TABSIZE; ++i)
    1458     tab[i] = NULL;
    1459 
    1460   while (1)
    1461     {
    1462       if (sig_termfast == 1)  /* SIGTERM */
    1463         {
    1464           TPT((0, FIL__, __LINE__, _("msg=<Terminate.>\n")));
    1465           --sig_raised; --sig_urgent;
    1466           retval = 1; exitval = EXIT_SUCCESS;
    1467           SH_FREE(line);
    1468           line = NULL;
    1469           goto unlock_and_return;
    1470         }
    1471 
    1472       p = sh_hash_getdataent (fd, line, MAX_PATH_STORE+1);
    1473       if (p != NULL)
    1474         {
    1475           hashinsert (p);
    1476           ++count;
    1477         }
    1478       else
    1479         break;
    1480     }
    1481 
    1482757  /* Initialization completed.
    1483758   */
    1484   IsInit = 1;
    1485 
    1486   if (line != NULL)
    1487     SH_FREE(line);
    1488 
    1489   /* Always keep db in memory, so we have no open file
    1490    */
    1491   sl_close (fd);
    1492   sh_hash_getline_end();
    1493   /* fd = -1; */
     759  retval = sh_dbIO_load_db(tab);
     760
     761  if (0 == retval)
     762    IsInit = 1;
     763  else
     764    exitval = EXIT_FAILURE;
    1494765
    1495766 unlock_and_return:
    … …  
    1500771      SL_RET0(_("sh_hash_init"));
    1501772    }
     773  sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_EXIT_ABORT1, sh.prg_name);
    1502774  aud_exit (FIL__, __LINE__, exitval);
     775}
     776
     777void sh_hash_init_and_checksum()
     778{
     779  TPT((0, FIL__, __LINE__, _("msg=<Get checksum of the database.>\n")))
     780  if (sh.flag.checkSum == SH_CHECK_CHECK)
     781    {
     782      if (0 != sl_strcmp(file_path('D', 'R'), _("REQ_FROM_SERVER")))
     783        {
     784          char hashbuf[KEYBUF_SIZE];
     785          (void) sl_strlcpy(sh.data.hash,
     786                            sh_tiger_hash (file_path('D', 'R'),
     787                                           TIGER_FILE, TIGER_NOLIM,
     788                                           hashbuf, sizeof(hashbuf)),
     789                            KEY_LEN+1);
     790        }
     791
     792      /* this eventually fetches the file from server to get checksum
     793       */
     794      sh_hash_init ();
     795    }
     796  return;
    1503797}
    1504798 
    … …  
    1536830}
    1537831
    1538 /******************************************************************
    1539  *
    1540  * Insert a file into the database.
    1541  *
    1542  ******************************************************************/
    1543 static int       pushdata_isfirst =  1;
    1544 static SL_TICKET pushdata_fd      = -1;
    1545 
    1546 static int       pushdata_stdout  =  S_FALSE;
    1547 
    1548 static char * sh_db_version_string = NULL;
    1549 
    1550 int sh_hash_pushdata_stdout (const char * str)
    1551 {
    1552   if (!str)
    1553     { pushdata_stdout  =  S_TRUE; return 0; }
    1554   return -1;
    1555 }
    1556 
    1557 int sh_hash_version_string(const char * str)
    1558 {
    1559   if (str)
    1560     {
    1561       if (sh_db_version_string != NULL) {
    1562         SH_FREE(sh_db_version_string);
    1563       }
    1564       if (0 == sl_strncmp(str, _("NULL"), 4))
    1565         {
    1566           sh_db_version_string = NULL;
    1567           return 0;
    1568         }
    1569       sh_db_version_string = sh_util_strdup(str);
    1570       return 0;
    1571     }
    1572   return -1;
    1573 }
    1574 
    1575832static int sh_loosedircheck = S_FALSE;
    1576833
    … …  
    1581838
    1582839
    1583 static void sh_hash_pushdata_int (file_type * buf, char * fileHash)
    1584 {
    1585   static long p_count = 0;
    1586 
    1587   int         status = 0;
    1588 
    1589   char      * tmp;
    1590   size_t      tmp_len = 0;
    1591   size_t      old_len = 0;
    1592   size_t      path_len = 0;
    1593 
    1594   sh_filestore_t p;
    1595 
    1596   struct stat sbuf;
    1597 
    1598   char *  fullpath = NULL;
    1599   char *  linkpath = NULL;
    1600   char *  attr_string = NULL;
    1601 
    1602   char * line = NULL;
    1603 
    1604   char   timestring[81];
    1605 
    1606 #if !defined(__linux__) && !defined(HAVE_STAT_FLAGS)
    1607   int    i;
    1608 #endif
    1609 
    1610   SL_ENTER(_("sh_hash_pushdata_int"));
    1611 
    1612   fullpath = SH_ALLOC(MAX_PATH_STORE+1);
    1613   linkpath = SH_ALLOC(MAX_PATH_STORE+1);
    1614 
    1615   linkpath[0] =  '-';
    1616   linkpath[1] = '\0';
    1617   fullpath[0] =  '-';
    1618   fullpath[1] = '\0';
    1619 
    1620   if (!buf) {
    1621     memset(&p, '\0', sizeof(sh_filestore_t));
    1622   }
    1623 
    1624   if ((pushdata_stdout == S_TRUE) && (sh.flag.update == S_TRUE))
    1625     {
    1626       dlog(1, FIL__, __LINE__,
    1627            _("You cannot write the database to stdout when you use update rather than init.\n"));
    1628       sh_error_handle((-1), FIL__, __LINE__, 0, MSG_EXIT_ABORTS,
    1629                       _("Writing database to stdout with update"),
    1630                       sh.prg_name,
    1631                       _("sh_hash_pushdata_int"));
    1632       aud_exit(FIL__, __LINE__, EXIT_FAILURE);
    1633     }
    1634 
    1635   if ((pushdata_stdout == S_TRUE) && (sl_is_suid()))
    1636     {
    1637       dlog(1, FIL__, __LINE__,
    1638            _("You cannot write the database to stdout when running with suid privileges.\n"));
    1639       sh_error_handle((-1), FIL__, __LINE__, 0, MSG_EXIT_ABORTS,
    1640                       _("Writing database to stdout when suid"),
    1641                       sh.prg_name,
    1642                       _("sh_hash_pushdata_int"));
    1643       aud_exit(FIL__, __LINE__, EXIT_FAILURE);
    1644     }
    1645 
    1646 
    1647   if ((pushdata_isfirst == 1) && (pushdata_stdout == S_FALSE) &&
    1648       ( (NULL == file_path('D', 'W')) ||
    1649         (0 == sl_strcmp(file_path('D', 'W'), _("REQ_FROM_SERVER"))) ))
    1650     {
    1651       dlog(1, FIL__, __LINE__,
    1652            _("You need to configure a local path for initializing the database\nlike ./configure --with-data-file=REQ_FROM_SERVER/some/local/path\n"));
    1653       sh_error_handle((-1), FIL__, __LINE__, 0, MSG_EXIT_ABORTS,
    1654                       _("No local path for database specified"),
    1655                       sh.prg_name,
    1656                       _("sh_hash_pushdata_int"));
    1657       aud_exit(FIL__, __LINE__, EXIT_FAILURE);
    1658     }
    1659 
    1660 
    1661   if ((pushdata_isfirst == 1) && (pushdata_stdout == S_FALSE)) 
    1662     {
    1663       /* Warn that file already exists; file_path != NULL here because
    1664        * checked above
    1665        */
    1666       if (0 == retry_lstat(FIL__, __LINE__, file_path('D', 'W'), &sbuf))
    1667         {
    1668           if (sh.flag.update == S_FALSE)
    1669             {
    1670               sh_error_handle((-1), FIL__, __LINE__, 0, MSG_FI_DBEX,
    1671                               file_path('D', 'W'));
    1672             }
    1673         }
    1674     }
    1675 
    1676 
    1677   if (sh.flag.update == S_FALSE)
    1678     {
    1679       if (pushdata_stdout == S_FALSE && pushdata_fd == -1)
    1680         {
    1681           if ( SL_ISERROR(pushdata_fd = sl_open_write(FIL__, __LINE__,
    1682                                                       file_path('D', 'W'),
    1683                                                       SL_YESPRIV)))
    1684             {
    1685               SH_FREE(fullpath);
    1686               SH_FREE(linkpath);
    1687               sh_error_handle((-1), FIL__, __LINE__, pushdata_fd, MSG_E_ACCESS,
    1688                               geteuid(), file_path('D', 'W'));
    1689               aud_exit(FIL__, __LINE__, EXIT_FAILURE);
    1690             }
    1691 
    1692           if (SL_ISERROR(status = sl_lock (pushdata_fd)))
    1693             {
    1694               SH_FREE(fullpath);
    1695               SH_FREE(linkpath);
    1696               sh_error_handle((-1), FIL__, __LINE__, status, MSG_E_SUBGPATH,
    1697                               _("Failed to lock baseline database"), _("sh_hash_pushdata_int"),
    1698                               file_path('D', 'W'));
    1699               aud_exit(FIL__, __LINE__, EXIT_FAILURE);
    1700             }
    1701 
    1702           if ( SL_ISERROR(status = sl_forward(pushdata_fd)))
    1703             {
    1704               SH_FREE(fullpath);
    1705               SH_FREE(linkpath);
    1706               sh_error_handle((-1), FIL__, __LINE__, status, MSG_E_SUBGPATH,
    1707                               _("Failed to seek to end of baseline database"),
    1708                               _("sh_hash_pushdata_int"),
    1709                               file_path('D', 'W'));
    1710               aud_exit(FIL__, __LINE__, EXIT_FAILURE);
    1711             }
    1712         }
    1713     }
    1714   else /* update == TRUE */
    1715     {
    1716       if (pushdata_isfirst == 1)
    1717         {
    1718           TPT((0, FIL__, __LINE__, _("msg=<Update.>\n")))
    1719             if ( SL_ISERROR(pushdata_fd = sl_open_rdwr(FIL__, __LINE__,
    1720                                                        file_path('D', 'W'),
    1721                                                        SL_YESPRIV))){
    1722               SH_FREE(fullpath);
    1723               SH_FREE(linkpath);
    1724               sh_error_handle((-1), FIL__, __LINE__, pushdata_fd, MSG_E_ACCESS,
    1725                               geteuid(), file_path('D', 'W'));
    1726               aud_exit(FIL__, __LINE__, EXIT_FAILURE);
    1727             }
    1728 
    1729           if (SL_ISERROR(status = sl_lock (pushdata_fd)))
    1730             {
    1731               SH_FREE(fullpath);
    1732               SH_FREE(linkpath);
    1733               sh_error_handle((-1), FIL__, __LINE__, status, MSG_E_SUBGPATH,
    1734                               _("Failed to lock baseline database"), _("sh_hash_pushdata_int"),
    1735                               file_path('D', 'W'));
    1736               aud_exit(FIL__, __LINE__, EXIT_FAILURE);
    1737             }
    1738 
    1739           line = SH_ALLOC(MAX_PATH_STORE+1);
    1740           if (SL_ISERROR(sh_hash_setdataent_old (pushdata_fd, line,
    1741                                                  MAX_PATH_STORE,
    1742                                                  file_path('D', 'W'))))
    1743             {
    1744               SH_FREE(fullpath);
    1745               SH_FREE(linkpath);
    1746               SH_FREE(line);
    1747               aud_exit(FIL__, __LINE__, EXIT_FAILURE);
    1748             }
    1749           SH_FREE(line);
    1750         }
    1751     }
    1752          
    1753   if (buf != NULL) {
    1754 
    1755     old_len = sl_strlen(buf->fullpath);
    1756 #if defined(SH_STEALTH)
    1757     sh_do_encode(buf->fullpath, old_len);
    1758 #endif
    1759     tmp = quote_string(buf->fullpath, old_len);
    1760     tmp_len = sl_strlen(tmp);
    1761 #if defined(SH_STEALTH)
    1762     sh_do_decode(buf->fullpath, old_len);
    1763 #endif
    1764 
    1765     if (tmp && tmp_len <= MAX_PATH_STORE)
    1766       {
    1767         sl_strlcpy(fullpath, buf->fullpath, MAX_PATH_STORE+1);
    1768       }
    1769     else
    1770       {
    1771         char hashbuf[KEYBUF_SIZE];
    1772 
    1773         sl_strlcpy(fullpath,
    1774                    sh_tiger_hash (buf->fullpath,
    1775                                   TIGER_DATA, old_len,
    1776                                   hashbuf, sizeof(hashbuf)),
    1777                    KEY_LEN+1);
    1778       }
    1779     if (tmp) SH_FREE(tmp);
    1780   }
    1781 
    1782   path_len = sl_strlen(fullpath);
    1783 #if defined(SH_STEALTH)
    1784   sh_do_encode(fullpath, path_len);
    1785 #endif
    1786 
    1787   tmp = quote_string(fullpath, path_len);
    1788   if (tmp) {
    1789     sl_strlcpy(fullpath, tmp, MAX_PATH_STORE+1);
    1790     SH_FREE(tmp);
    1791   }
    1792 
    1793   /* NOTE: TXT entries are c_mode[0] != 'l' and do not get decoded
    1794    */
    1795   if (buf != NULL /* && buf->c_mode[0] == 'l' */ && buf->link_path != NULL)
    1796     { 
    1797 
    1798       old_len = sl_strlen(buf->link_path);
    1799 #if defined(SH_STEALTH)
    1800       if (buf->c_mode[0] == 'l')
    1801         sh_do_encode(buf->link_path, old_len);
    1802 #endif
    1803       tmp = quote_string(buf->link_path, old_len);
    1804       tmp_len = sl_strlen(tmp);
    1805 #if defined(SH_STEALTH)
    1806       if (buf->c_mode[0] == 'l')
    1807         sh_do_decode(buf->link_path, old_len);
    1808 #endif
    1809 
    1810       if (tmp && tmp_len <= MAX_PATH_STORE)
    1811         {
    1812           sl_strlcpy(linkpath, buf->link_path, MAX_PATH_STORE+1); 
    1813         }
    1814       else
    1815         {
    1816           char hashbuf[KEYBUF_SIZE];
    1817           sl_strlcpy(linkpath,
    1818                      sh_tiger_hash (buf->link_path,
    1819                                     TIGER_DATA, old_len,
    1820                                     hashbuf, sizeof(hashbuf)),
    1821                      KEY_LEN+1);
    1822         }
    1823       if (tmp) SH_FREE(tmp);
    1824 
    1825       path_len = sl_strlen(linkpath);
    1826 #if defined(SH_STEALTH)
    1827       if (buf->c_mode[0] == 'l')
    1828         sh_do_encode(linkpath, path_len);
    1829 #endif
    1830       tmp = quote_string(linkpath, path_len);
    1831       if (tmp)
    1832         {
    1833           sl_strlcpy(linkpath, tmp, MAX_PATH_STORE+1);
    1834           SH_FREE(tmp);
    1835         }
    1836     }
    1837 
    1838   if (buf != NULL && buf->attr_string != NULL)
    1839     {
    1840       old_len = sl_strlen(buf->attr_string);
    1841 #if defined(SH_STEALTH)
    1842       sh_do_encode(buf->attr_string, old_len);
    1843 #endif
    1844       tmp = quote_string(buf->attr_string, old_len);
    1845       if (tmp)
    1846         {
    1847           attr_string = tmp;
    1848           tmp = NULL;
    1849         }
    1850 #if defined(SH_STEALTH)
    1851       sh_do_decode(buf->attr_string, old_len);
    1852 #endif
    1853     }
    1854 
    1855 
    1856   if (buf != NULL) {
    1857     p.mark = REC_MAGIC;
    1858     if (attr_string)
    1859       p.mark |= REC_FLAGS_ATTR;
    1860     sl_strlcpy(p.c_mode,   buf->c_mode,   CMODE_SIZE);
    1861     sl_strlcpy(p.c_group,  buf->c_group,  GROUP_MAX+1);
    1862     sl_strlcpy(p.c_owner,  buf->c_owner,  USER_MAX+1);
    1863     if (fileHash) {
    1864       sl_strlcpy(p.checksum, fileHash,      KEY_LEN+1);
    1865     }
    1866 #if defined(__linux__) || defined(HAVE_STAT_FLAGS)
    1867     sl_strlcpy(p.c_attributes, buf->c_attributes, ATTRBUF_SIZE);
    1868 #else
    1869     for (i = 0; i < ATTRBUF_USED; ++i) p.c_attributes[i] = '-';
    1870     p.c_attributes[ATTRBUF_USED] = '\0';
    1871 #endif
    1872    
    1873 #if defined(SH_STEALTH)
    1874     sh_do_encode(p.c_mode,   sl_strlen(p.c_mode));
    1875     sh_do_encode(p.c_owner,  sl_strlen(p.c_owner));
    1876     sh_do_encode(p.c_group,  sl_strlen(p.c_group));
    1877     sh_do_encode(p.checksum, sl_strlen(p.checksum));
    1878 
    1879     sh_do_encode(p.c_attributes,   sl_strlen(p.c_attributes));
    1880 #endif
    1881    
    1882 #if defined(__linux__) || defined(HAVE_STAT_FLAGS)
    1883     p.attributes  = (UINT32) buf->attributes;
    1884 #else
    1885     p.attributes  = 0;
    1886 #endif
    1887     p.linkmode    = (UINT32) buf->linkmode;
    1888     p.hardlinks   = (UINT32) buf->hardlinks;
    1889     p.dev   = (UINT64) buf->dev;
    1890     p.rdev  = (UINT64) buf->rdev;
    1891     p.mode  = (UINT32) buf->mode;
    1892     p.ino   = (UINT32) buf->ino;
    1893     p.size  = (UINT64) buf->size;
    1894     p.mtime = (UINT64) buf->mtime;
    1895     p.atime = (UINT64) buf->atime;
    1896     p.ctime = (UINT64) buf->ctime;
    1897     p.owner = (UINT32) buf->owner;
    1898     p.group = (UINT32) buf->group;
    1899    
    1900     swap_32(&(p.mode));
    1901     swap_32(&(p.linkmode));
    1902     swap_64(&(p.dev));
    1903     swap_64(&(p.rdev));
    1904     swap_32(&(p.hardlinks));
    1905     swap_32(&(p.ino));
    1906     swap_64(&(p.size));
    1907     swap_64(&(p.atime));
    1908     swap_64(&(p.mtime));
    1909     swap_64(&(p.ctime));
    1910     swap_32(&(p.owner));
    1911     swap_32(&(p.group));
    1912     swap_32(&(p.attributes));
    1913 
    1914 #ifdef OLD_BUG
    1915     swap_short(&(p.mark));
    1916 #else
    1917     p.mark = *(swap_short(&(p.mark)));
    1918 #endif
    1919   }
    1920 
    1921   /* write the start marker
    1922    */
    1923   if (pushdata_isfirst == 1)
    1924     {
    1925       if (sh.flag.update == S_FALSE)
    1926         {
    1927           if (sh_db_version_string != NULL)
    1928             {
    1929               if (pushdata_stdout == S_FALSE)
    1930                 {
    1931                   sl_write (pushdata_fd, _("\n#Host "), 7);
    1932                   sl_write (pushdata_fd, sh.host.name,
    1933                             sl_strlen(sh.host.name));
    1934                   sl_write (pushdata_fd, _(" Version "), 9);
    1935                   sl_write (pushdata_fd, sh_db_version_string,
    1936                             sl_strlen(sh_db_version_string));
    1937                   sl_write (pushdata_fd, _(" Date "), 6);
    1938                   (void) sh_unix_time(0, timestring, sizeof(timestring));
    1939                   sl_write (pushdata_fd, timestring, strlen(timestring));
    1940                   sl_write (pushdata_fd,        "\n", 1);
    1941                 } else {
    1942                   printf ("%s",_("\n#Host "));
    1943                   printf ("%s", sh.host.name);
    1944                   printf ("%s",_(" Version "));
    1945                   printf ("%s", sh_db_version_string);
    1946                   printf ("%s",_(" Date "));
    1947                   (void) sh_unix_time(0, timestring, sizeof(timestring));
    1948                   printf ("%s\n", timestring);
    1949                 }
    1950             }
    1951 
    1952           if (pushdata_stdout == S_FALSE)
    1953             {
    1954 #if defined(SH_STEALTH)
    1955               sl_write      (pushdata_fd,        "\n", 1);
    1956               sl_write_line (pushdata_fd, N_("[SOF]"), 5);
    1957 #else
    1958               sl_write_line (pushdata_fd, _("\n[SOF]"),  6);
    1959 #endif
    1960             }
    1961           else
    1962             {
    1963 #if defined(SH_STEALTH)
    1964               printf ("\n%s\n", N_("[SOF]"));
    1965 #else
    1966               printf ("%s\n", _("\n[SOF]"));
    1967 #endif
    1968             }
    1969         }
    1970       pushdata_isfirst = 0;
    1971     }
    1972      
    1973   if (pushdata_stdout == S_FALSE)
    1974     {
    1975       sl_write      (pushdata_fd,       &p, sizeof(sh_filestore_t));
    1976       sl_write_line_fast (pushdata_fd, fullpath, sl_strlen(fullpath));
    1977       sl_write_line_fast (pushdata_fd, linkpath, sl_strlen(linkpath));
    1978       if (attr_string)
    1979         sl_write_line_fast (pushdata_fd, attr_string, sl_strlen(attr_string));
    1980     } else {
    1981       if (fwrite (&p, sizeof(sh_filestore_t), 1, stdout))
    1982         {
    1983           printf ("%s\n", fullpath);
    1984           printf ("%s\n", linkpath);
    1985           if (attr_string)
    1986             printf ("%s\n", attr_string);
    1987         }
    1988       else
    1989         {
    1990           perror(_("Error writing database"));
    1991           aud_exit (FIL__, __LINE__, EXIT_FAILURE);
    1992         }
    1993     }
    1994 
    1995   ++p_count;
    1996 
    1997   if ((sh.flag.update != S_TRUE) && (pushdata_stdout == S_FALSE))
    1998     {
    1999       if (sh.flag.checkSum != SH_CHECK_INIT || (buf == NULL && fileHash == NULL))
    2000         {
    2001           sl_close (pushdata_fd);
    2002           pushdata_fd = -1;
    2003         }
    2004     }
    2005 
    2006   SH_FREE(fullpath);
    2007   SH_FREE(linkpath);
    2008   if (attr_string)
    2009     SH_FREE(attr_string);
    2010 
    2011   SL_RET0(_("sh_hash_pushdata_int"));
    2012 }
    2013 
    2014 SH_MUTEX_STATIC(mutex_writeout,PTHREAD_MUTEX_INITIALIZER);
    2015 
    2016 void sh_hash_pushdata (file_type * buf, char * fileHash)
    2017 {
    2018   SH_MUTEX_LOCK(mutex_writeout);
    2019   sh_hash_pushdata_int (buf, fileHash);
    2020   SH_MUTEX_UNLOCK(mutex_writeout);
    2021   return;
    2022 }
    2023 
    2024 
    2025 int sh_hash_writeout()
    2026 {
    2027   sh_file_t * p;
    2028   int         i;
    2029   file_type * f;
    2030   char   fileHash[KEY_LEN + 1];
    2031 
    2032   SL_ENTER(_("sh_hash_writeout"));
    2033 
    2034   if (S_TRUE == file_is_remote())
    2035     {
    2036       sh_error_handle((-1), FIL__, __LINE__, S_FALSE, MSG_E_SUBGEN,
    2037                       _("Baseline database is remote"), _("sh_hash_writeout"));
    2038       SL_RETURN (1, _("sh_hash_writeout"));
    2039     }
    2040 
    2041   SH_MUTEX_LOCK(mutex_writeout);
    2042   if (!SL_ISERROR(pushdata_fd))
    2043     {
    2044       sl_close(pushdata_fd);
    2045       pushdata_fd = -1;
    2046     }
    2047   pushdata_isfirst =  1;
    2048 
    2049 
    2050   SH_MUTEX_LOCK(mutex_hash);
    2051   for (i = 0; i < TABSIZE; ++i)
    2052     {
    2053       for (p = tab[i]; p; p = p->next)
    2054         {
    2055           f = sh_hash_create_ft (p, fileHash);
    2056           sh_hash_pushdata_int (f, fileHash);
    2057           if (f->attr_string) SH_FREE(f->attr_string);
    2058           if (f->link_path)   SH_FREE(f->link_path);
    2059           SH_FREE(f);
    2060         }
    2061     }
    2062   SH_MUTEX_UNLOCK(mutex_hash);
    2063 
    2064   if (!SL_ISERROR(pushdata_fd))
    2065     {
    2066       sl_close(pushdata_fd);
    2067       pushdata_fd = -1;
    2068     }
    2069   pushdata_isfirst =  1;
    2070   SH_MUTEX_UNLOCK(mutex_writeout);
    2071 
    2072   SL_RETURN (0, _("sh_hash_writeout"));
    2073 }
    2074840
    2075841
    … …  
    23781144  sl_strlcpy(tmpFile->c_group, _("root"), 5);
    23791145
     1146  tmpFile->check_flags = 0;
     1147
    23801148  if ((str != NULL) && (size < (PATH_MAX/2)-1))
    23811149    {
    … …  
    24041172
    24051173  if (sh.flag.checkSum == SH_CHECK_INIT)
    2406     sh_hash_pushdata (tmpFile,
    2407                       (save->checksum[0] == '\0') ? SH_KEY_NULL : save->checksum);
     1174    sh_dbIO_data_write (tmpFile,
     1175                        (save->checksum[0] == '\0') ? SH_KEY_NULL : save->checksum);
    24081176  else
    24091177    sh_hash_pushdata_memory (tmpFile,
    … …  
    25241292  p.group = (UINT32) buf->group;
    25251293
     1294  p.checkflags = (UINT32) buf->check_flags;
     1295
    25261296  memcpy( &(*fp).theFile, &p, sizeof(sh_filestore_t) );
    25271297  fp->fflags    = 0;  /* init fflags */
    … …  
    26231393  msg[0] = '\0';
    26241394
     1395  if (report_checkflags != S_FALSE)
     1396    {
     1397      if (is_new)
     1398        format = _("checkflags_new=\"0%lo\" ");
     1399      else
     1400        format = _("checkflags_old=\"0%lo\" ");
     1401      sl_snprintf(tmp, SH_MSG_BUF, format,
     1402                  (unsigned long) theFile->check_flags);
     1403      sl_strlcat(msg, tmp, SH_MSG_BUF);
     1404    }
    26251405
    26261406#if defined(__linux__) || defined(HAVE_STAT_FLAGS)
    … …  
    27901570  msg[0] = '\0';
    27911571
     1572  if (report_checkflags == S_TRUE)
     1573    {
     1574      if (is_new)
     1575        format = _("checkflags_new=<0%lo> ");
     1576      else
     1577        format = _("checkflags_old=<0%lo> ");
     1578      sl_snprintf(tmp, SH_MSG_BUF, format,
     1579                  (unsigned long) theFile->check_flags);
     1580      sl_strlcat(msg, tmp, SH_MSG_BUF);
     1581    }
     1582
    27921583
    27931584#if defined(__linux__) || defined(HAVE_STAT_FLAGS)
    … …  
    29521743    {
    29531744      SH_MUTEX_LOCK(mutex_hash);
    2954       hashinsert (p);
    2955       p->modi_mask = theFile->check_mask;
     1745      hashinsert (tab, p);
     1746      p->modi_mask = theFile->check_flags;
    29561747      SH_MUTEX_UNLOCK(mutex_hash);
    29571748    }
    … …  
    29601751}
    29611752
     1753int sh_hash_is_null_file(file_type * theFile)
     1754{
     1755  if (theFile->hardlinks == SH_DEADFILE && theFile->mode  == 0 &&
     1756      theFile->ino == 0                 && theFile->ctime == 0)
     1757    {
     1758      return S_TRUE;
     1759    }
     1760  return S_FALSE;
     1761}
     1762
     1763int sh_hash_is_null_record(sh_filestore_t * theFile)
     1764{
     1765  if (theFile->hardlinks == SH_DEADFILE && theFile->mode  == 0 &&
     1766      theFile->ino == 0                 && theFile->ctime == 0)
     1767    {
     1768      return S_TRUE;
     1769    }
     1770  return S_FALSE;
     1771}
     1772
     1773void sh_hash_insert_null(char * str)
     1774{
     1775  file_type theFile = { 0, 0, {'\0'}, 0, 0, 0, 0, 0,
     1776#if defined(__linux__) || defined(HAVE_STAT_FLAGS)
     1777                        0, {'\0'},
     1778#endif
     1779                        {'\0'}, 0, {'\0'}, 0, {'\0'},
     1780                        0, 0, 0, 0, 0, 0, 0, NULL,  0, {'\0'}, 0, NULL
     1781  }; /* clang compiler bails out on standard conforming init with just {0} */
     1782  char      fileHash[KEY_LEN+1];
     1783  char      hashbuf[KEYBUF_SIZE];
     1784
     1785  sl_strlcpy(fileHash, SH_KEY_NULL, sizeof(fileHash));
     1786  theFile.hardlinks = SH_DEADFILE;
     1787
     1788  if (sl_strlen(str) < PATH_MAX)
     1789    sl_strlcpy(theFile.fullpath, str, PATH_MAX);
     1790  else
     1791     sl_strlcpy(theFile.fullpath,
     1792                sh_tiger_hash(str, TIGER_DATA, sl_strlen(str),
     1793                              hashbuf, sizeof(hashbuf)),
     1794                PATH_MAX);
     1795
     1796  sh_hash_pushdata_memory(&theFile, fileHash);
     1797  return;
     1798}
     1799
     1800static int handle_notfound(int  log_severity, int class,
     1801                           file_type * theFile, char * fileHash)
     1802{
     1803  sh_file_t * p;
     1804  int         retval = 0;
     1805
     1806  if (S_FALSE == sh_ignore_chk_new(theFile->fullpath))
     1807    {
     1808      char * tmp = sh_util_safe_name(theFile->fullpath);
     1809      char * str;
     1810
     1811      sh_files_fixup_mask(class, &(theFile->check_flags));
     1812      str = all_items (theFile, fileHash, 1);
     1813     
     1814      sh_error_handle (log_severity, FIL__, __LINE__, 0,
     1815                       MSG_FI_ADD2,
     1816                       tmp, str);
     1817      ++sh.statistics.files_report;
     1818      SH_FREE(str);
     1819      SH_FREE(tmp);
     1820    }
     1821 
     1822  if (sh.flag.reportonce == S_TRUE)
     1823    SET_SH_FFLAG_REPORTED(theFile->file_reported);
     1824 
     1825  if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
     1826    {
     1827      p = sh_hash_push_int(theFile, fileHash);
     1828      if (p)
     1829        {
     1830          hashinsert (tab, p);
     1831          p->modi_mask = theFile->check_flags;
     1832          p->theFile.checkflags = p->modi_mask;
     1833        }
     1834    }
     1835 
     1836  else if (S_TRUE == sh.flag.update)
     1837    {
     1838      if (S_TRUE == sh_util_ask_update (theFile->fullpath))
     1839        {
     1840          p = sh_hash_push_int(theFile, fileHash);
     1841          if (p)
     1842            {
     1843              hashinsert (tab, p);
     1844              p->modi_mask = theFile->check_flags;
     1845              p->theFile.checkflags = p->modi_mask;
     1846            }
     1847        }
     1848      else
     1849        retval = 1;
     1850    }
     1851  return retval;
     1852}
    29621853
    29631854/*****************************************************************
    … …  
    29751866  char * tmp_lnk;
    29761867  char * tmp_lnk_old;
    2977 
    2978   char * str;
    29791868
    29801869  char timstr1c[32];
    … …  
    29961885  volatile int  log_severity;
    29971886  char hashbuf[KEYBUF_SIZE];
     1887  struct {
     1888    unsigned long oldflags;
     1889    unsigned long newflags;
     1890  } cf_report;
    29981891
    29991892  int  retval;
    … …  
    30331926  if (p == NULL)
    30341927    {
    3035       if (S_FALSE == sh_ignore_chk_new(theFile->fullpath))
    3036         {
    3037           tmp = sh_util_safe_name(theFile->fullpath);
    3038 
    3039           str = all_items (theFile, fileHash, 1);
    3040           sh_error_handle (log_severity, FIL__, __LINE__, 0,
    3041                            MSG_FI_ADD2,
    3042                            tmp, str);
    3043           ++sh.statistics.files_report;
    3044           SH_FREE(str);
    3045 
    3046           SH_FREE(tmp);
    3047         }
    3048 
    3049       if (sh.flag.reportonce == S_TRUE)
    3050         SET_SH_FFLAG_REPORTED(theFile->file_reported);
    3051 
    3052       if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
    3053         {
    3054           p = sh_hash_push_int(theFile, fileHash);
    3055           if (p)
    3056             {
    3057               hashinsert (p);
    3058               p->modi_mask = theFile->check_mask;
    3059             }
    3060         }
    3061 
    3062       else if (S_TRUE == sh.flag.update)
    3063         {
    3064           if (S_TRUE == sh_util_ask_update (theFile->fullpath))
    3065             {
    3066               p = sh_hash_push_int(theFile, fileHash);
    3067               if (p)
    3068                 {
    3069                   hashinsert (p);
    3070                   p->modi_mask = theFile->check_mask;
    3071                 }
    3072             }
    3073           else
    3074             {
    3075               retval = 1;
    3076               goto unlock_and_return;
    3077             }
    3078         }
    3079 
     1928      retval = handle_notfound(log_severity, class, theFile, fileHash);
    30801929      goto unlock_and_return;
    30811930    }
    … …  
    30861935  if (S_TRUE == sh_ignore_chk_mod(theFile->fullpath))
    30871936    {
     1937      MODI_SET(theFile->check_flags, MODI_NOCHECK);
     1938      p->modi_mask = theFile->check_flags;
     1939      p->theFile.checkflags = p->modi_mask;
    30881940      goto unlock_and_return;
    30891941    }
    30901942
    3091   p->modi_mask = theFile->check_mask;
     1943  cf_report.oldflags = p->theFile.checkflags;
     1944  cf_report.newflags = theFile->check_flags;
     1945
     1946  p->modi_mask = theFile->check_flags;
     1947  p->theFile.checkflags = p->modi_mask;
    30921948
    30931949  /* initialize change_code */
    … …  
    31011957  if ( (fileHash != NULL) &&
    31021958       (strncmp (fileHash, p->theFile.checksum, KEY_LEN) != 0) &&
    3103        (theFile->check_mask & MODI_CHK) != 0)
    3104     {
    3105       if ((theFile->check_mask & MODI_SGROW) == 0)
     1959       (theFile->check_flags & MODI_CHK) != 0)
     1960    {
     1961      if ((theFile->check_flags & MODI_SGROW) == 0)
    31061962        {
    31071963          modi_mask |= MODI_CHK;
    … …  
    31141970            {
    31151971              if (S_FALSE == sh_check_rotated_log (theFile->fullpath, (UINT64) p->theFile.size,
    3116                                                    (UINT64) p->theFile.ino, p->theFile.checksum))
     1972                                                   (UINT64) p->theFile.ino, p->theFile.checksum,
     1973                                                   p->theFile.checkflags))
    31171974                {
    31181975                  modi_mask |= MODI_CHK;
    … …  
    31391996    {
    31401997      if (!(theFile->link_path) &&
    3141           (theFile->check_mask & MODI_LNK) != 0)
     1998          (theFile->check_flags & MODI_LNK) != 0)
    31421999        {
    31432000          linkComp = NULL;
    … …  
    31662023         
    31672024          if ( sl_strncmp (linkComp, p->linkpath, maxcomp) != 0 &&
    3168                (theFile->check_mask & MODI_LNK) != 0)
     2025               (theFile->check_flags & MODI_LNK) != 0)
    31692026            {
    31702027              modi_mask |= MODI_LNK;
    … …  
    31792036      if ( ( major(theFile->rdev) != major((dev_t)p->theFile.rdev) ||
    31802037             minor(theFile->rdev) != minor((dev_t)p->theFile.rdev) ) &&
    3181            (theFile->check_mask & MODI_RDEV) != 0)
     2038           (theFile->check_flags & MODI_RDEV) != 0)
    31822039        {
    31832040          modi_mask |= MODI_RDEV;
    … …  
    31902047   */
    31912048  if ( (UINT32) theFile->ino != (UINT32) p->theFile.ino  &&
    3192        (theFile->check_mask & MODI_INO) != 0)
     2049       (theFile->check_flags & MODI_INO) != 0)
    31932050    {
    31942051      modi_mask |= MODI_INO;
    … …  
    31982055   
    31992056  if ( theFile->hardlinks != (nlink_t) p->theFile.hardlinks &&
    3200        (theFile->check_mask & MODI_HLN) != 0)
     2057       (theFile->check_flags & MODI_HLN) != 0)
    32012058    {
    32022059      modi_mask |= MODI_HLN;
    … …  
    32202077#endif
    32212078          )
    3222        && (theFile->check_mask & MODI_MOD) != 0)
     2079       && (theFile->check_flags & MODI_MOD) != 0)
    32232080    {
    32242081      modi_mask |= MODI_MOD;
    … …  
    32282085       * report link path if switch link/no link
    32292086       */
    3230       if ((theFile->check_mask & MODI_LNK) != 0 &&
     2087      if ((theFile->check_flags & MODI_LNK) != 0 &&
    32312088          (theFile->c_mode[0] != p->theFile.c_mode[0]) &&
    32322089          (theFile->c_mode[0] == 'l' || p->theFile.c_mode[0] == 'l'))
    … …  
    32392096
    32402097  if ( theFile->owner != (uid_t) p->theFile.owner &&
    3241        (theFile->check_mask & MODI_USR) != 0)
     2098       (theFile->check_flags & MODI_USR) != 0)
    32422099    {
    32432100      modi_mask |= MODI_USR;
    … …  
    32472104
    32482105  if ( theFile->group != (gid_t) p->theFile.group &&
    3249        (theFile->check_mask & MODI_GRP) != 0)
     2106       (theFile->check_flags & MODI_GRP) != 0)
    32502107    {
    32512108      modi_mask |= MODI_GRP;
    … …  
    32562113 
    32572114  if ( theFile->mtime != (time_t) p->theFile.mtime &&
    3258        (theFile->check_mask & MODI_MTM) != 0)
     2115       (theFile->check_flags & MODI_MTM) != 0)
    32592116    {
    32602117      modi_mask |= MODI_MTM;
    … …  
    32632120    }
    32642121 
    3265   if ( (theFile->check_mask & MODI_ATM) != 0 &&
     2122  if ( (theFile->check_flags & MODI_ATM) != 0 &&
    32662123       theFile->atime != (time_t) p->theFile.atime)
    32672124    {
    … …  
    32762133   */
    32772134  if ( theFile->ctime != (time_t) p->theFile.ctime &&
    3278        (theFile->check_mask & MODI_CTM) != 0)
     2135       (theFile->check_flags & MODI_CTM) != 0)
    32792136    {
    32802137      modi_mask |= MODI_CTM;
    … …  
    32842141
    32852142  if ( theFile->size != (off_t) p->theFile.size &&
    3286        (theFile->check_mask & MODI_SIZ) != 0)
    3287     {
    3288       if ((theFile->check_mask & MODI_SGROW) == 0 ||
     2143       (theFile->check_flags & MODI_SIZ) != 0)
     2144    {
     2145      if ((theFile->check_flags & MODI_SGROW) == 0 ||
    32892146          theFile->size < (off_t) p->theFile.size)
    32902147        {
    … …  
    33092166  if (modi_mask != 0 && sh.flag.fulldetail == S_TRUE)
    33102167    {
    3311       if ((theFile->check_mask & MODI_ATM) == 0)
     2168      if ((theFile->check_flags & MODI_ATM) == 0)
    33122169        modi_mask = MASK_READONLY_;
    33132170      else
    … …  
    33222179      msg = SH_ALLOC(SH_MSG_BUF);
    33232180      msg[0] = '\0';
     2181
     2182      sh_files_fixup_mask(class, &(cf_report.newflags));
     2183
     2184      if ( (report_checkflags != S_FALSE) && (cf_report.oldflags != cf_report.newflags))
     2185        {
     2186          sl_snprintf(tmp, SH_MSG_BUF,
     2187#ifdef SH_USE_XML
     2188                      _("checkflags_old=\"0%lo\" checkflags_new=\"0%lo\" "),
     2189#else
     2190                      _("checkflags_old=<0%lo>, checkflags_new=<0%lo>, "),
     2191#endif
     2192                      cf_report.oldflags,  cf_report.newflags);
     2193          sl_strlcat(msg, tmp, SH_MSG_BUF);
     2194        }
    33242195
    33252196      if (   ((modi_mask & MODI_MOD) != 0)
    … …  
    33742245#endif
    33752246
    3376 #ifdef REPLACE_OLD
    33772247          if ((modi_mask & MODI_MOD) != 0)
    33782248            {
    … …  
    34052275                }
    34062276            }
    3407 #endif
     2277
    34082278        }
    34092279
    … …  
    34192289                      (unsigned long) theFile->hardlinks);
    34202290          sl_strlcat(msg, tmp, SH_MSG_BUF);
    3421 #ifdef REPLACE_OLD
     2291
    34222292          if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
    34232293            p->theFile.hardlinks = theFile->hardlinks;
    3424 #endif
    34252294        }
    34262295
    … …  
    34432312                      );
    34442313          sl_strlcat(msg, tmp, SH_MSG_BUF);
    3445 #ifdef REPLACE_OLD
     2314
    34462315          if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
    34472316            p->theFile.rdev = theFile->rdev;
    3448 #endif
    34492317        }
    34502318
    … …  
    34602328                      (unsigned long) theFile->ino);
    34612329          sl_strlcat(msg, tmp, SH_MSG_BUF);
    3462 #ifdef REPLACE_OLD
     2330
    34632331          if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
    34642332            {
    … …  
    34662334              p->theFile.dev = theFile->dev;
    34672335            }
    3468 #endif
    34692336        }
    34702337
    … …  
    34882355                      );
    34892356          sl_strlcat(msg, tmp, SH_MSG_BUF);
    3490 #ifdef REPLACE_OLD
     2357
    34912358          if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
    34922359            p->theFile.dev = theFile->dev;
    3493 #endif
    34942360        }
    34952361#endif
    … …  
    35122378                      );
    35132379          sl_strlcat(msg, tmp, SH_MSG_BUF);
    3514 #ifdef REPLACE_OLD
     2380
    35152381          if ((modi_mask & MODI_USR) != 0) {
    35162382            if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
    … …  
    35202386              }
    35212387          }
    3522 #endif
    35232388        }
    35242389
    … …  
    35422407
    35432408          sl_strlcat(msg, tmp, SH_MSG_BUF);
    3544 #ifdef REPLACE_OLD
     2409
    35452410          if ((modi_mask & MODI_GRP) != 0) {
    35462411            if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
    … …  
    35502415              }
    35512416          }
    3552 #endif
    35532417        }
    35542418
    … …  
    35592423                      (UINT64) theFile->size);
    35602424          sl_strlcat(msg, tmp, SH_MSG_BUF);
    3561 #ifdef REPLACE_OLD
     2425
    35622426          if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
    35632427            p->theFile.size = theFile->size;
    3564 #endif
    35652428        }
    35662429
    … …  
    35772440#endif
    35782441          sl_strlcat(msg, tmp, SH_MSG_BUF);
    3579 #ifdef REPLACE_OLD
     2442
    35802443          if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
    35812444            p->theFile.ctime = theFile->ctime;
    3582 #endif
    35832445        }
    35842446
    … …  
    35952457#endif
    35962458          sl_strlcat(msg, tmp, SH_MSG_BUF);
    3597 #ifdef REPLACE_OLD
     2459
    35982460          if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
    35992461            p->theFile.atime = theFile->atime;
    3600 #endif
    36012462        }
    36022463
    … …  
    36132474#endif
    36142475          sl_strlcat(msg, tmp, SH_MSG_BUF);
    3615 #ifdef REPLACE_OLD
     2476
    36162477          if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
    36172478            p->theFile.mtime = theFile->mtime;
    3618 #endif
    36192479        }
    36202480
    … …  
    36302490                      p->theFile.checksum, fileHash);
    36312491          sl_strlcat(msg, tmp, SH_MSG_BUF);
    3632 #ifdef REPLACE_OLD
     2492
    36332493          if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
    36342494            {
    36352495              sl_strlcpy(p->theFile.checksum, fileHash, KEY_LEN+1);
    3636               if ((theFile->check_mask & MODI_SGROW) != 0)           
     2496              if ((theFile->check_flags & MODI_SGROW) != 0)           
    36372497                p->theFile.size  = theFile->size;
    36382498            }
    3639 #endif
    3640           /* FIXME is this correct? */
     2499
     2500
    36412501          if (theFile->c_mode[0] != 'l' && theFile->link_path &&
    36422502              strlen(theFile->link_path) > 2)
    … …  
    36652525          SH_FREE(tmp_lnk_old);
    36662526          sl_strlcat(msg, tmp, SH_MSG_BUF);
    3667 #ifdef REPLACE_OLD
     2527
    36682528          if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
    36692529            {
    3670               if (p->linkpath != NULL && p->linkpath != notalink)
     2530              if (p->linkpath != NULL)
    36712531                SH_FREE(p->linkpath);
    3672               if (!(theFile->link_path) ||
    3673                   (theFile->link_path[0] == '-' && theFile->link_path[1] == '\0'))
    3674                 p->linkpath = (char *)notalink;
     2532              if (!(theFile->link_path))
     2533                p->linkpath = sh_util_strdup("-");
    36752534              else
    36762535                p->linkpath = sh_util_strdup(theFile->link_path);
    36772536            }
    3678 #endif
    3679         }
    3680 
    3681       if (MODI_AUDIT_ENABLED(theFile->check_mask))
     2537        }
     2538
     2539      if (MODI_AUDIT_ENABLED(theFile->check_flags))
    36822540        {
    36832541          char result[256];
    … …  
    37012559        }
    37022560
     2561      /****************************************************
     2562       *
     2563       * REPORT on file change
     2564       *
     2565       ****************************************************/
    37032566      tmp_path = sh_util_safe_name(theFile->fullpath);
    37042567      sh_error_handle(log_severity, FIL__, __LINE__,
    … …  
    37112574      SH_FREE(tmp);
    37122575      SH_FREE(msg);
    3713 
    3714 #ifndef REPLACE_OLD
    3715       SET_SH_FFLAG_REPORTED(p->fflags);
    3716 #endif
    37172576
    37182577      if (S_TRUE  == sh.flag.update)
    … …  
    37572616                  if (theFile->link_path)
    37582617                    SH_FREE(theFile->link_path);
    3759                   if (p->linkpath && p->linkpath != notalink)
     2618                  if (p->linkpath)
    37602619                    theFile->link_path = sh_util_strdup(p->linkpath);
    37612620                  else
    … …  
    38152674              if (theFile->c_mode[0] == 'l' || theFile->link_path)
    38162675                {
    3817                   if (p->linkpath != NULL && p->linkpath != notalink)
     2676                  if (p->linkpath != NULL)
    38182677                    SH_FREE(p->linkpath);
    38192678                  p->linkpath = sh_util_strdup(theFile->link_path);
    … …  
    38212680              else
    38222681                {
    3823                   if (p->linkpath != NULL && p->linkpath != notalink) {
     2682                  if (p->linkpath != NULL)
    38242683                    SH_FREE(p->linkpath);
    3825                   }
    3826                   p->linkpath = (char *)notalink;
     2684                  p->linkpath = sh_util_strdup("-");
    38272685                }
    38282686             
    … …  
    39552813            {
    39562814              /* if (0 == strncmp(s, p->fullpath, len_s)) *//* old */
    3957               if (S_TRUE == hash_remove_tree_test(s, p->fullpath, len_s))
     2815              if (S_TRUE == hash_remove_tree_test(s, p->fullpath, len_s)) {
    39582816                SET_SH_FFLAG_ALLIGNORE(p->fflags);
     2817                MODI_SET(p->theFile.checkflags, MODI_ALLIGNORE);
     2818              }
    39592819            } /* if path is not null */
    39602820
    … …  
    39842844  ListFile = sh_util_strdup(c);
    39852845  return 0;
     2846}
     2847char * get_list_file()
     2848{
     2849  return ListFile;
    39862850}
    39872851
    … …  
    42313095  time_t now  = time(NULL);
    42323096  time_t then = (time_t) p->theFile.mtime;
     3097  struct tm   * time_ptr;
    42333098
    42343099#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GMTIME_R)
    4235   struct tm   * time_ptr;
    42363100  struct tm     time_tm;
    4237 
     3101#endif
     3102
     3103  if (ListFullDetail != S_FALSE)
     3104    {
     3105      sh_hash_list_db_entry_full_detail (p);
     3106      return;
     3107    }
     3108
     3109#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GMTIME_R)
    42383110  time_ptr = gmtime_r(&then, &time_tm);
     3111  if (!time_ptr)
     3112    return;
    42393113  strftime(thetime, 127, _("%b %d  %Y"), time_ptr);
    42403114  time_ptr = gmtime_r(&now,  &time_tm);
     3115  if (!time_ptr)
     3116    return;
    42413117  strftime(nowtime, 127, _("%b %d  %Y"), time_ptr);
    42423118  if (0 == strncmp(&nowtime[7], &thetime[7], 4))
    42433119    {
    42443120      time_ptr = gmtime_r(&then, &time_tm);
     3121      if (!time_ptr)
     3122        return;
    42453123      strftime(thetime, 127, _("%b %d %H:%M"), time_ptr);
    42463124    }
    42473125#else
    4248   strftime(thetime, 127, _("%b %d  %Y"), gmtime(&then));
    4249   strftime(nowtime, 127, _("%b %d  %Y"), gmtime(&now));
     3126  time_ptr = gmtime(&then);
     3127  if (!time_ptr)
     3128    return;
     3129  strftime(thetime, 127, _("%b %d  %Y"), time_ptr);
     3130  time_ptr = gmtime(&now);
     3131  if (!time_ptr)
     3132    return;
     3133  strftime(nowtime, 127, _("%b %d  %Y"), time_ptr);
    42503134  if (0 == strncmp(&nowtime[7], &thetime[7], 4))
    4251     strftime(thetime, 127, _("%b %d %H:%M"), gmtime(&then));
     3135    {
     3136      time_ptr = gmtime(&then);
     3137      if (!time_ptr)
     3138        return;
     3139      strftime(thetime, 127, _("%b %d %H:%M"), time_ptr);
     3140    }
    42523141#endif
    42533142
    … …  
    43273216}
    43283217
    4329 int sh_hash_list_db (const char * db_file)
    4330 {
    4331   sh_file_t * p;
    4332   SL_TICKET fd;
    4333   char * line;
    4334   int  flag = 0;
    4335 
    4336   if (!db_file)
    4337     {
    4338       _exit(EXIT_FAILURE);
    4339       return -1;
    4340     }
    4341   if (sl_is_suid())
    4342     {
    4343       fprintf(stderr, "%s",_("ERROR: insufficient privilege\n"));
    4344       _exit (EXIT_FAILURE);
    4345       return -1; /* for Mac OSX compiler */
    4346     }
    4347   if (0 == strcmp(db_file, _("default")))
    4348     db_file = file_path('D', 'W');
    4349   if (!db_file)
    4350     {
    4351       _exit(EXIT_FAILURE);
    4352       return -1;
    4353     }
    4354 
    4355   line = SH_ALLOC(MAX_PATH_STORE+2);
    4356 
    4357   if ( SL_ISERROR(fd = sl_open_read(FIL__, __LINE__, db_file, SL_YESPRIV)))
    4358     {
    4359       fprintf(stderr, _("ERROR: can't open %s for read (errnum = %ld)\n"),
    4360               db_file, fd);
    4361       _exit(EXIT_FAILURE);
    4362       return -1;
    4363     }
    4364 
    4365   /* fast forward to start of data
    4366    */
    4367   sh_hash_setdataent(fd, line, MAX_PATH_STORE+1, db_file);
    4368 
    4369   while (1)
    4370     {
    4371       p = sh_hash_getdataent (fd, line, MAX_PATH_STORE+1);
    4372       if ((p != NULL) && (p->fullpath[0] == '/'))
    4373         {
    4374           if (!ListFile)
    4375             {
    4376               flag = 1;
    4377               if (ListFullDetail == S_FALSE)
    4378                 sh_hash_list_db_entry (p);
    4379               else
    4380                 sh_hash_list_db_entry_full_detail (p);
    4381             }
    4382           else
    4383             {
    4384               if (0 != sl_strcmp(ListFile, p->fullpath))
    4385                 {
    4386                   continue;
    4387                 }
    4388               flag = 1;
    4389               if ('l' != p->theFile.c_mode[0])
    4390                 {
    4391                   if (sh_hash_printcontent(p->linkpath) < 0)
    4392                     {
    4393                       _exit(EXIT_FAILURE);
    4394                       return -1;
    4395                     }
    4396                 }
    4397               else
    4398                 {
    4399                   fprintf(stderr, "%s",_("File is a link\n"));
    4400                   _exit(EXIT_FAILURE);
    4401                   return -1;
    4402                 }
    4403               break;
    4404             }
    4405         }
    4406       else if (p == NULL)
    4407         {
    4408           break;
    4409         }
    4410     }
    4411 
    4412   if (line != NULL)
    4413     SH_FREE(line);
    4414   sl_close (fd);
    4415 
    4416   fflush(NULL);
    4417 
    4418   if (flag == 0)
    4419     {
    4420       fprintf(stderr, "%s",_("File not found\n"));
    4421       _exit(EXIT_FAILURE);
    4422     }
    4423   _exit(EXIT_SUCCESS);
    4424   return 0;
    4425 }
    4426 
    44273218/* if defined(SH_WITH_CLIENT) || defined(SH_STANDALONE) */
    44283219#endif

  • trunk/src/sh_html.c

    r473 r481  
    4141
    4242#include "samhain.h"
    43 #include "sh_forward.h"
     43#include "sh_xfer.h"
    4444#include "sh_error.h"
    4545#include "sh_unix.h"
    … …  
    159159          if (time_ptr != NULL)
    160160            strftime (ts1, 80, _("%d-%m-%Y %H:%M:%S"), time_ptr);
     161          else
     162            sl_strlcpy(ts1, _("01-01-1970 00:00:00"), sizeof(ts1));
    161163          now = time(NULL);
    162164#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R)
    … …  
    167169          if (time_ptr != NULL)
    168170            strftime (ts2, 80, _("%d-%m-%Y %H:%M:%S"), time_ptr);
     171          else
     172            sl_strlcpy(ts2, _("01-01-1970 00:00:00"), sizeof(ts2));
    169173
    170174          sl_snprintf(outline, 1023,
    … …  
    193197              if (time_ptr != NULL)
    194198                strftime (ts1, 80, _("%d-%m-%Y %H:%M:%S"), time_ptr);
     199              else
     200                sl_strlcpy(ts1, _("01-01-1970 00:00:00"), sizeof(ts1));
    195201              sl_snprintf(outline, 1023,
    196202                          _("<p>Last connection at %s</p>"),
    … …  
    416422  int status;
    417423  int clt_status;
    418   int i, n;
     424  unsigned int i, n;
    419425
    420426  SL_ENTER(_("sh_html_print_one"));

  • trunk/src/sh_ignore.c

    r438 r481  
    7373  SL_ENTER(_("sh_ignore_add"));
    7474
    75   if ( (addpath == NULL) || (sl_ok_adds(2, strlen(addpath)) == SL_FALSE) )
     75  if ( (addpath == NULL) || (sl_ok_adds(2, strlen(addpath)) == S_FALSE) )
    7676    {
    7777      SL_RETURN(list, _("sh_ignore_add"));

  • trunk/src/sh_inotify.c

    r474 r481  
    135135  int    class;
    136136  int    rdepth;
    137   unsigned long check_mask;
     137  unsigned long check_flags;
    138138  char * file;
    139139} sh_watch;
    … …  
    236236  int     ifd = sh_inotify_getfd();
    237237
    238   len = sl_read_timeout_fd (ifd, buffer, count, timeout, SL_FALSE);
     238  len = sl_read_timeout_fd (ifd, buffer, count, timeout, S_FALSE);
    239239
    240240  return len;
    … …  
    364364
    365365char * sh_inotify_pop_dormant(sh_watches * watches,
    366                               int * class, unsigned long * check_mask,
     366                              int * class, unsigned long * check_flags,
    367367                              int * type, int * rdepth)
    368368{
    … …  
    384384      *type   = this->watch->type;
    385385      *rdepth = this->watch->rdepth;
    386       *check_mask = this->watch->check_mask;
     386      *check_flags = this->watch->check_flags;
    387387      popret  = sh_util_strdup_track(this->watch->file, __FILE__, __LINE__);
    388388
    … …  
    424424static zAVLKey sh_inotify_getkey(void const *item)
    425425{
    426   return (&((sh_watch *)item)->watch);
     426  return (&((const sh_watch *)item)->watch);
    427427}
    428428
    … …  
    490490int sh_inotify_add_watch_later(const char * filename, sh_watches * watches,
    491491                               int * errnum,
    492                                int class, unsigned long check_mask, int type,
     492                               int class, unsigned long check_flags, int type,
    493493                               int rdepth)
    494494{
    … …  
    500500  item->type       = (short) type;
    501501  item->rdepth     = (short) rdepth;
    502   item->check_mask = check_mask;
     502  item->check_flags = check_flags;
    503503
    504504  sh_inotify_add_dormant(watches, item);
    … …  
    548548
    549549  extern void sh_fInotify_report_add(char * path,
    550                                      int class, unsigned long check_mask);
     550                                     int class, unsigned long check_flags);
    551551
    552552  sh_dummy_litem = (void*) &litem;
    … …  
    575575              SH_MUTEX_UNLOCK(mutex_watches);
    576576
    577               sh_fInotify_report_add(litem->file, litem->class, litem->check_mask);
     577              sh_fInotify_report_add(litem->file, litem->class, litem->check_flags);
    578578
    579579              litem = sh_inotify_list_del_cur(&listcursor, save);
    … …  
    592592 */
    593593int sh_inotify_add_watch(char * filename, sh_watches * watches, int * errnum,
    594                          int class, unsigned long check_mask, int type, int rdepth)
     594                         int class, unsigned long check_flags, int type, int rdepth)
    595595{
    596596  volatile int retval = 0;
    … …  
    637637          item->type       = type;
    638638          item->rdepth     = rdepth;
    639           item->check_mask = check_mask;
     639          item->check_flags = check_flags;
    640640         
    641641          if (NULL == watches->list_of_watches)
    … …  
    692692
    693693char * sh_inotify_search_item(sh_watches * watches, int watch,
    694                               int * class, unsigned long * check_mask,
     694                              int * class, unsigned long * check_flags,
    695695                              int * type, int * rdepth)
    696696{
    … …  
    709709    {
    710710      *class      = item->class;
    711       *check_mask = item->check_mask;
     711      *check_flags = item->check_flags;
    712712      *type       = item->type;
    713713      *rdepth     = item->rdepth;
    … …  
    882882
    883883int sh_inotify_add_watch(char * filename, sh_watches * watches, int  * errnum,
    884                          int class, unsigned long check_mask, int type, int rdepth)
     884                         int class, unsigned long check_flags, int type, int rdepth)
    885885{
    886886  (void) filename;
    887887  (void) watches;
    888888  (void) class;
    889   (void) check_mask;
     889  (void) check_flags;
    890890  (void) type;
    891891  (void) rdepth;
    … …  
    898898int sh_inotify_add_watch_later(const char * filename, sh_watches * watches,
    899899                               int  * errnum,
    900                                int class, unsigned long check_mask, int type, int rdepth)
     900                               int class, unsigned long check_flags, int type, int rdepth)
    901901{
    902902  (void) filename;
    903903  (void) watches;
    904904  (void) class;
    905   (void) check_mask;
     905  (void) check_flags;
    906906  (void) type;
    907907  (void) rdepth;
    … …  
    927927  int type;
    928928  int rdepth;
    929   unsigned long check_mask;
     929  unsigned long check_flags;
    930930  int           nrun = 0;
    931931
    … …  
    10221022    CuAssertIntEquals(tc, count, 5);
    10231023   
    1024     p = sh_inotify_pop_dormant(&twatch, &class, &check_mask, &type, &rdepth);
     1024    p = sh_inotify_pop_dormant(&twatch, &class, &check_flags, &type, &rdepth);
    10251025    CuAssertStrEquals(tc, p, "a5");
    10261026   
    1027     p = sh_inotify_pop_dormant(&twatch, &class, &check_mask, &type, &rdepth);
     1027    p = sh_inotify_pop_dormant(&twatch, &class, &check_flags, &type, &rdepth);
    10281028    CuAssertStrEquals(tc, p, "a3");
    10291029    CuAssertIntEquals(tc, class, 3);
    10301030   
    1031     p = sh_inotify_pop_dormant(&twatch, &class, &check_mask, &type, &rdepth);
     1031    p = sh_inotify_pop_dormant(&twatch, &class, &check_flags, &type, &rdepth);
    10321032    CuAssertTrue(tc, NULL == p);
    10331033    CuAssertTrue(tc, NULL == twatch.dormant_watches);

  • trunk/src/sh_ipvx.c

    r449 r481  
    165165                        name, name_size, NULL, 0, NI_NUMERICHOST);
    166166
    167 
    168   /* fprintf(stderr, "FIXME: Error %s (%d), name %s (%d)\n",
    169      gai_strerror(ret), ret, name, name_size); */
    170 
    171167  if (ret != 0 && name_size > 0)
    172168    {
    … …  
    343339}
    344340
    345 static void * sh_dummy_out;
     341void * sh_dummy_341_out;
    346342
    347343char * sh_ipvx_canonical(const char * hostname, char * numeric, size_t nlen)
    … …  
    361357  numeric[0] = '\0';
    362358
    363   sh_dummy_out = (void *) &out;
     359  sh_dummy_341_out = (void *) &out;
    364360 
    365361  if (sh_ipvx_is_numeric(hostname))
    … …  
    426422  numeric[0] = '\0';
    427423
    428   sh_dummy_out = (void *) &out;
     424  sh_dummy_341_out = (void *) &out;
    429425
    430426  if (sh_ipvx_is_numeric(hostname))

  • trunk/src/sh_log_check.c

    r425 r481  
    143143                  size_t  plen = strlen(entry->d_name) + 1;
    144144
    145                   if (SL_TRUE == sl_ok_adds(plen, dlen))
     145                  if (S_TRUE == sl_ok_adds(plen, dlen))
    146146                    {
    147147                      plen += dlen;
    … …  
    180180      plen = strlen(dir);
    181181
    182       if (SL_TRUE == sl_ok_adds(plen, 130))
     182      if (S_TRUE == sl_ok_adds(plen, 130))
    183183        {
    184184          plen += 130; /* 64 + 64 + 2 */
    … …  
    500500 * by longjmp' warning. And no, 'volatile' proved insufficient.
    501501 */
    502 static void * sh_dummy_thisfile = NULL;
     502void * sh_dummy_502_thisfile = NULL;
    503503
    504504void sh_check_watches()
    … …  
    512512   * Avoids the 'clobbered by longjmp' warning.
    513513   */
    514   sh_dummy_thisfile = (void*) &thisfile;
     514  sh_dummy_502_thisfile = (void*) &thisfile;
    515515
    516516  while (thisfile)

  • trunk/src/sh_log_correlate.c

    r358 r481  
    105105int sh_keep_comp(const void * a, const void * b)
    106106{
    107   return ( (int)(((struct sh_keep *)a)->last) -
    108            (int)(((struct sh_keep *)b)->last) );
     107  return ( (int)(((const struct sh_keep *)a)->last) -
     108           (int)(((const struct sh_keep *)b)->last) );
    109109}
    110110

  • trunk/src/sh_log_evalrule.c

    r383 r481  
    470470}
    471471
    472 static struct sh_qeval ** dummy_queue;
    473 static char            ** dummy_dstr;
     472struct sh_qeval ** sh_dummy_472_queue;
     473char            ** sh_dummy_473_dstr;
    474474
    475475int sh_eval_radd (const char * str)
    … …  
    477477  struct sh_geval * nr;
    478478  struct sh_geval * tmp;
    479   struct sh_qeval * queue = NULL;
     479  struct sh_qeval * queue;
    480480  pcre *  rule;
    481481  pcre_extra * rule_extra;
    … …  
    506506  splits = split_array(new, &nfields, ':', lengths);
    507507
    508   dummy_queue = &queue;
    509   dummy_dstr  = &dstr;
     508  sh_dummy_472_queue = &queue;
     509  sh_dummy_473_dstr  = &dstr;
     510
     511  queue = NULL;
    510512
    511513  if (nfields < 2 || nfields > 3)
    … …  
    593595  pcre_fullinfo(rule, rule_extra, PCRE_INFO_CAPTURECOUNT, &captures);
    594596
    595   if (flag_err_debug == SL_TRUE)
     597  if (flag_err_debug == S_TRUE)
    596598    {
    597599      char * emsg = SH_ALLOC(SH_ERRBUF_SIZE);
    … …  
    654656  if (group_open)
    655657    {
    656       if (flag_err_debug == SL_TRUE)
     658      if (flag_err_debug == S_TRUE)
    657659        {
    658660          char * emsg = SH_ALLOC(SH_ERRBUF_SIZE);
    … …  
    826828 * filled in
    827829 */
    828 static struct sh_geval ** dummy1;
     830struct sh_geval ** sh_dummy_828_rule;
    829831
    830832static struct sh_geval * test_rule (struct sh_geval * rule, sh_string *msg, time_t tstamp)
    … …  
    834836  volatile time_t timestamp = tstamp;
    835837
    836   dummy1 = &rule;
     838  sh_dummy_828_rule = &rule;
    837839
    838840  if (!rule)
    … …  
    844846      do {
    845847
    846         if (flag_err_debug == SL_TRUE)
     848        if (flag_err_debug == S_TRUE)
    847849          {
    848850            char * emsg = SH_ALLOC(SH_ERRBUF_SIZE);
    … …  
    864866            rule->ovecnum = res;
    865867
    866             if (flag_err_debug == SL_TRUE)
     868            if (flag_err_debug == S_TRUE)
    867869              {
    868870                char * emsg = SH_ALLOC(SH_ERRBUF_SIZE);
    … …  
    900902          }
    901903
    902         if (flag_err_debug == SL_TRUE)
     904        if (flag_err_debug == S_TRUE)
    903905          {
    904906            char * emsg = SH_ALLOC(SH_ERRBUF_SIZE);
    … …  
    919921    DEBUG("debug: no match found\n");
    920922  /* If there was no match, this is NULL */
    921   dummy1 = NULL;
     923  sh_dummy_828_rule = NULL;
    922924  return rule;
    923925}
    … …  
    926928 * against msg
    927929 */
    928 static struct sh_geval ** dummy2;
    929 static struct sh_geval ** dummy3;
     930struct sh_geval ** sh_dummy_928_result;
     931struct sh_geval ** sh_dummy_929_group;
    930932
    931933static struct sh_geval * test_grules (struct sh_heval * host,
    … …  
    936938  struct sh_geval * group  = host->rulegroups;
    937939
    938   dummy2 = &result;
    939   dummy3 = &group;
     940  sh_dummy_928_result = &result;
     941  sh_dummy_929_group = &group;
    940942
    941943  if (group && sh_string_len(msg) < (size_t)INT_MAX)
    … …  
    947949            /* this is a rule group */
    948950
    949             if (flag_err_debug == SL_TRUE)
     951            if (flag_err_debug == S_TRUE)
    950952              {
    951953                char * emsg = SH_ALLOC(SH_ERRBUF_SIZE);
    … …  
    975977             */
    976978
    977             if (flag_err_debug == SL_TRUE)
     979            if (flag_err_debug == S_TRUE)
    978980              {
    979981                char * emsg = SH_ALLOC(SH_ERRBUF_SIZE);
    … …  
    995997    }
    996998
    997   dummy2 = NULL;
    998   dummy3 = NULL;
     999  sh_dummy_928_result = NULL;
     1000  sh_dummy_929_group = NULL;
    9991001  return result;
    10001002}
    … …  
    11131115static zAVLKey sh_eval_getkey(void const *item)
    11141116{
    1115   return ((struct sh_ceval *)item)->hostname->str;
     1117  return ((const struct sh_ceval *)item)->hostname->str;
    11161118}
    11171119

  • trunk/src/sh_log_mark.c

    r363 r481  
    6868static zAVLKey sh_log_mark_getkey(void const *item)
    6969{
    70   return ((struct sh_mark_event *)item)->label->str;
     70  return ((const struct sh_mark_event *)item)->label->str;
    7171}
    7272

  • trunk/src/sh_log_parse_apache.c

    r362 r481  
    6363 * by longjmp' warning. And no, 'volatile' proved insufficient.
    6464 */
    65 static void * sh_dummy_new = NULL;
    66 static void * sh_dummy_fti = NULL;
    67 static void * sh_dummy_ftr = NULL;
     65void * sh_dummy_65_new = NULL;
     66void * sh_dummy_66_fti = NULL;
     67void * sh_dummy_67_ftr = NULL;
    6868
    6969void * sh_eval_fileinfo_apache(char * str)
    … …  
    8888   * Avoids the 'clobbered by longjmp' warning.
    8989   */
    90   sh_dummy_new = (void*) &new;
    91   sh_dummy_fti = (void*) &f_time;
    92   sh_dummy_ftr = (void*) &result;
     90  sh_dummy_65_new = (void*) &new;
     91  sh_dummy_66_fti = (void*) &f_time;
     92  sh_dummy_67_ftr = (void*) &result;
    9393
    9494  if (0 == strncmp("common", str, 6))
    … …  
    109109    }
    110110
    111   if (flag_err_debug == SL_TRUE)
     111  if (flag_err_debug == S_TRUE)
    112112    {
    113113      SH_MUTEX_LOCK(mutex_thread_nolog);
    … …  
    251251  sh_string_add_from_char(re_string, "$");
    252252
    253   if (flag_err_debug == SL_TRUE)
     253  if (flag_err_debug == S_TRUE)
    254254    {
    255255      SH_MUTEX_LOCK(mutex_thread_nolog);
    … …  
    304304  char         tstr[128];
    305305  char         sstr[128];
    306   char      * hstr;
     306  const char * hstr;
    307307  int          res;
    308308  const char **hstr_addr = (const char **) &hstr;
    … …  
    310310  struct sh_fileinfo_apache * info = (struct sh_fileinfo_apache *) fileinfo;
    311311
    312   if (sh_string_len(logline) > 0 && flag_err_debug == SL_TRUE)
     312  if (sh_string_len(logline) > 0 && flag_err_debug == S_TRUE)
    313313    {
    314314      SH_MUTEX_LOCK(mutex_thread_nolog);
    … …  
    409409      record->pid       = PID_INVALID;
    410410
    411       pcre_free(hstr);
     411      pcre_free_substring(hstr);
    412412      return record;
    413413    }

  • trunk/src/sh_log_parse_generic.c

    r362 r481  
    4646static void default_time (struct sh_logrecord * record)
    4747{
    48   struct tm ts;
     48  struct tm   ts;
     49  struct tm * ts_ptr;
    4950  char   tmp[80];
    5051  size_t len;
    … …  
    5354 
    5455#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R)
    55   localtime_r (&(record->timestamp), &ts);
     56  ts_ptr = localtime_r (&(record->timestamp), &ts);
    5657#else
    57   memcpy(&ts, localtime(&(record->timestamp)), sizeof(struct tm));
     58  ts_ptr = localtime(&(record->timestamp));
     59  if (ts_ptr)
     60    memcpy(&ts, ts_ptr, sizeof(struct tm));
    5861#endif
    59   len = strftime(tmp, sizeof(tmp), _("%Y-%m-%dT%H:%M:%S"), &ts);
    60 
     62  if (ts_ptr)
     63    len = strftime(tmp, sizeof(tmp), _("%Y-%m-%dT%H:%M:%S"), &ts);
     64  else
     65    {
     66      sl_strlcpy(tmp, _("1970-01-01T00:00:00"), sizeof(tmp));
     67      len = strlen(tmp);
     68    }
    6169  record->timestr   = sh_string_new_from_lchar(tmp, len);
    6270

  • trunk/src/sh_log_parse_pacct.c

    r384 r481  
    292292}
    293293
    294 static void * sh_dummy_record = NULL;
     294void * sh_dummy_294_record = NULL;
    295295
    296296struct sh_logrecord * sh_parse_pacct (sh_string * logline, void * fileinfo)
    … …  
    303303  (void) fileinfo;
    304304
    305   sh_dummy_record = (void *) &record;
    306 
    307   if (sh_string_len(logline) > 0 && flag_err_debug == SL_TRUE)
     305  sh_dummy_294_record = (void *) &record;
     306
     307  if (sh_string_len(logline) > 0 && flag_err_debug == S_TRUE)
    308308    {
    309309      SH_MUTEX_LOCK(mutex_thread_nolog);

  • trunk/src/sh_log_parse_syslog.c

    r357 r481  
    7878
    7979
    80   if (flag_err_debug == SL_TRUE && sh_string_len(logline) > 0)
     80  if (flag_err_debug == S_TRUE && sh_string_len(logline) > 0)
    8181    {
    8282      SH_MUTEX_LOCK(mutex_thread_nolog);

  • trunk/src/sh_mail.c

    r383 r481  
    6969#undef  BAD
    7070
    71 static int failedMail = SL_FALSE;
     71static int failedMail = S_FALSE;
    7272
    7373static dnsrep * return_mx (char *domain);
    … …  
    337337  SL_ENTER(_("sh_mail_pushstack"));
    338338
    339   if (msg == NULL || failedMail == SL_TRUE /* || sh.srvmail.name[0] == '\0' */)
     339  if (msg == NULL || failedMail == S_TRUE /* || sh.srvmail.name[0] == '\0' */)
    340340    SL_RETURN((0), (_("sh_mail_pushstack")));
    341341
    … …  
    550550     * Return if we cannot mail.
    551551     */
    552     if (failedMail == SL_TRUE)
     552    if (failedMail == S_TRUE)
    553553      SL_RETURN((-1), _("sh_mail_msg"));
    554554
    … …  
    564564        sh_mail_emptystack();
    565565        sh.mailNum.alarm_last = 0;
    566         failedMail = SL_TRUE;
     566        failedMail = S_TRUE;
    567567        SL_RETURN((-1), _("sh_mail_msg"));
    568568      }
    … …  
    12591259  my_time = time(NULL);
    12601260#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R)
    1261   my_tm   = localtime_r(&my_time, &time_tm);
     1261  my_tm = localtime_r(&my_time, &time_tm);
    12621262#else
    1263   my_tm   = localtime(&my_time);
    1264 #endif
    1265 
     1263  my_tm = localtime(&my_time);
     1264#endif
     1265 
     1266  if (!my_tm)
     1267    {
     1268      sl_strlcpy(my_tbuf, _("Thu, 01 Jan 1970 00:00:00 +00:00"), sizeof(my_tbuf));
     1269    }
     1270  else
     1271    {
    12661272#if defined(HAVE_STRFTIME_Z)
    1267   (void)    strftime(my_tbuf, 127, _("%a, %d %b %Y %H:%M:%S %z"), my_tm);
     1273      (void) strftime(my_tbuf, 127, _("%a, %d %b %Y %H:%M:%S %z"), my_tm);
    12681274#else
    1269   (void)    strftime(my_tbuf, 127, _("%a, %d %b %Y %H:%M:%S %Z"), my_tm);
    1270 #endif
     1275      (void) strftime(my_tbuf, 127, _("%a, %d %b %Y %H:%M:%S %Z"), my_tm);
     1276#endif
     1277    }
    12711278
    12721279  TPT(( 0, FIL__, __LINE__,  _("msg=<From: <%s>%c%cTo: <%s>%c%cDate: %s>%c%c"),
    … …  
    13391346  char * tmp;
    13401347
    1341   if (flag_err_debug == SL_TRUE)
     1348  if (flag_err_debug == S_TRUE)
    13421349    {
    13431350      tmp = sh_util_safe_name_keepspace(reply);
    … …  
    13821389  reply[0] = '\0';
    13831390
    1384   while (sl_read_timeout_fd (ma_socket, &c, 1, time_wait, SL_FALSE) > 0) {
     1391  while (sl_read_timeout_fd (ma_socket, &c, 1, time_wait, S_FALSE) > 0) {
    13851392
    13861393    if (ireply < (sizeof(reply) - 1))

  • trunk/src/sh_mem.c

    r459 r481  
    112112#endif
    113113
    114 static memlist_t ** sh_mem_merr_1;
     114memlist_t ** sh_dummy_114_merrlist;
    115115
    116116void sh_mem_stat ()
    … …  
    121121  SL_ENTER(_("sh_mem_stat"));
    122122
    123   sh_mem_merr_1 = (memlist_t **) &merrlist;
     123  sh_dummy_114_merrlist = (memlist_t **) &merrlist;
    124124
    125125  if (Alloc_Count == Free_Count)
    … …  
    166166}
    167167
    168 static memlist_t ** sh_mem_merr_2;
     168memlist_t ** sh_dummy_168_merrlist;
    169169
    170170void sh_mem_check ()
    … …  
    177177  SL_ENTER(_("sh_mem_check"));
    178178
    179   sh_mem_merr_2 = (memlist_t **) &merrlist;
     179  sh_dummy_168_merrlist = (memlist_t **) &merrlist;
    180180
    181181  sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_MSTAMP,

  • trunk/src/sh_modules.c

    r372 r481  
    1212#include "sh_mounts.h"
    1313#include "sh_userfiles.h"
    14 #include "sh_kern.h"
    1514#include "sh_suidchk.h"
    1615#include "sh_processcheck.h"
    … …  
    6867    N_("[UserFiles]"),
    6968    sh_userfiles_table,
    70     PTHREAD_MUTEX_INITIALIZER,
    71   },
    72 #endif
    73 
    74 #ifdef SH_USE_KERN
    75   {
    76     N_("KERNEL"),
    77     -1,
    78     0,
    79     sh_kern_init,
    80     sh_kern_timer,
    81     sh_kern_check,
    82     sh_kern_end,
    83     sh_kern_null,
    84 
    85     N_("[Kernel]"),
    86     sh_kern_table,
    8769    PTHREAD_MUTEX_INITIALIZER,
    8870  },

  • trunk/src/sh_nmail.c

    r474 r481  
    329329                                      const void * rcv_info)
    330330{
    331   struct alias * rcv = (struct alias *) rcv_info;
     331  const struct alias * rcv = (const struct alias *) rcv_info;
    332332
    333333  if (!alias || 0 == strcmp(alias, sh_string_str(rcv->recipient)))

  • trunk/src/sh_port2proc.c

    r384 r481  
    945945      continue;
    946946
    947     /* fprintf(stderr, "FIXME: %d %d, %d %d, %d %d, %d, %d\n", s->proto, proto,
    948        s->family, AF_INET,
    949        sport, ntohs(((struct sockaddr_in *)(&s->laddr))->sin_port),
    950        (int) xf->xf_uid, (int)xf->xf_pid);
    951     */
    952 
    953947    if (s->proto != proto)
    954948      continue;
    … …  
    970964      haddr6 = &((struct sockaddr_in6 *)(&s->laddr))->sin6_addr;
    971965   
    972 
    973     /* fprintf(stderr, "FIXME: %s\n", inet_ntoa(*haddr)); */
    974     /* fprintf(stderr, "FIXME: %s\n", inet_ntoa(*saddr)); */
    975966
    976967    if ( (s->family == AF_INET &&

  • trunk/src/sh_portcheck.c

    r473 r481  
    529529 * by longjmp' warning. And no, 'volatile' proved insufficient.
    530530 */
    531 static void * sh_dummy_pre = NULL;
    532 static void * sh_dummy_ptr = NULL;
     531void * sh_dummy_531_pre = NULL;
     532void * sh_dummy_532_ptr = NULL;
    533533
    534534/* check the list of open ports for any that are marked as UNKN
    535535 */
    536 static void sh_portchk_check_list (struct sh_portentry ** head, int proto, int report)
     536static void sh_portchk_check_list (struct sh_portentry ** head,
     537                                   int proto, int report)
    537538{
    538539  struct sh_portentry * ptr = *head;
    … …  
    543544   * Avoids the 'clobbered by longjmp' warning.
    544545   */
    545   sh_dummy_pre = (void*) &pre;
    546   sh_dummy_ptr = (void*) &ptr;
     546  sh_dummy_531_pre = (void*) &pre;
     547  sh_dummy_532_ptr = (void*) &ptr;
    547548 
    548549  while (ptr)
    … …  
    616617    }
    617618
    618   sh_dummy_ptr = NULL;
    619   sh_dummy_pre = NULL;
     619  sh_dummy_532_ptr = NULL;
     620  sh_dummy_531_pre = NULL;
    620621
    621622  return;
    … …  
    15611562/* Subroutine to add an interface
    15621563 */
    1563 static void * sh_dummy_str    = NULL; /* fix clobbered by.. warning */
     1564void * sh_dummy_1564_str    = NULL; /* fix clobbered by.. warning */
    15641565
    15651566static int sh_portchk_add_interface (const char * str)
    … …  
    15691570  char buf[64];
    15701571
    1571   sh_dummy_str    = (void*) &str;
     1572  sh_dummy_1564_str    = (void*) &str;
    15721573
    15731574  if (iface_initialized == 0)
    … …  
    16101611  } while (*str);
    16111612
    1612   sh_dummy_str = NULL;
     1613  sh_dummy_1564_str = NULL;
    16131614  return 0;
    16141615}

  • trunk/src/sh_prelink.c

    r379 r481  
    8787    return S_FALSE;
    8888
    89   status = sl_read_timeout (fd, magic, 4, alert_timeout, SL_FALSE);
     89  status = sl_read_timeout (fd, magic, 4, alert_timeout, S_FALSE);
    9090  (void) sl_rewind(fd);
    9191  if (status == 4)
    … …  
    156156/* returns static storage
    157157 */
    158 int sh_prelink_run (char * path, char * file_hash, int alert_timeout)
     158int sh_prelink_run (char * path, char * file_hash, int alert_timeout, unsigned long mask)
    159159{
    160160  static int      init = S_FALSE;
    … …  
    262262    char hashbuf[KEYBUF_SIZE];
    263263    UINT64 length_nolim = TIGER_NOLIM;
     264    if (sh.flag.opts == S_TRUE) sh_tiger_set_hashtype_mask(mask);
    264265    sl_strlcpy(file_hash,
    265266               sh_tiger_generic_hash (path, task.pipeTI, &length_nolim, alert_timeout,

  • trunk/src/sh_processcheck.c

    r399 r481  
    411411 * by longjmp' warning. And no, 'volatile' proved insufficient.
    412412 */
    413 static void * sh_dummy_watchlist = NULL;
     413void * sh_dummy_413_watchlist = NULL;
    414414
    415415static void check_watchlist (short * res)
    … …  
    422422   * Avoids the 'clobbered by longjmp' warning.
    423423   */
    424   sh_dummy_watchlist = (void*) &list;
     424  sh_dummy_413_watchlist = (void*) &list;
    425425
    426426  while (list)
    … …  
    468468    }
    469469
    470   sh_dummy_watchlist = NULL;
     470  sh_dummy_413_watchlist = NULL;
    471471  return;
    472472}
    … …  
    625625  value = (size_t) strtoul(str, &foo, 0);
    626626
    627   if (*foo == '\0' && SL_TRUE == sl_ok_adds(value, 1)) {
     627  if (*foo == '\0' && S_TRUE == sl_ok_adds(value, 1)) {
    628628    sh_prochk_maxpid = value + 1;
    629629    userdef_maxpid   = 1;
    … …  
    934934            {
    935935              tstr[pos-1] = '\0';
    936               if (flag_err_debug == SL_TRUE)
     936              if (flag_err_debug == S_TRUE)
    937937                {
    938938                  SH_MUTEX_LOCK(mutex_thread_nolog);

  • trunk/src/sh_readconf.c

    r432 r481  
    3333#include "sh_unix.h"
    3434#include "sh_files.h"
    35 #include "sh_forward.h"
     35#include "sh_xfer.h"
    3636#include "sh_gpg.h"
    3737#include "sh_hash.h"
     38#include "sh_dbIO.h"
    3839#include "sh_ignore.h"
    3940#include "sh_database.h"
    … …  
    4950#include "sh_utils.h"
    5051#include "sh_restrict.h"
    51 
     52#include "sh_socket.h"
    5253
    5354extern int set_reverse_lookup (const char * c);
    … …  
    137138{
    138139#ifdef SH_EVAL_SHELL
    139   char * tmp = (char*)str;
     140  char * tmp = sh_util_strdup(str);
    140141  char * out;
     142  char * tmp_orig = tmp;
    141143
    142144  while (tmp && isspace((int)*tmp)) ++tmp;
    … …  
    150152          tmp[len-1] = '\0';
    151153          out = sh_ext_popen_str(&tmp[2]);
     154          SH_FREE(tmp_orig);
    152155          return out;
    153156        }
    154157    }
     158  SH_FREE(tmp_orig);
    155159#endif
    156160  return sh_util_strdup(str);
    … …  
    384388      sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_D_START);
    385389
    386       fd = sh_forward_req_file(_("CONF"));
     390      fd = sh_xfer_request_file(_("CONF"));
    387391
    388392      if (!SL_ISERROR(fd))
    … …  
    392396      else if (sh.flag.checkSum != SH_CHECK_INIT)
    393397        {
     398          sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_FBAD);
    394399          aud_exit (FIL__, __LINE__, EXIT_FAILURE);
    395400        }
    396401      else
    397402        {
     403          sh_error_handle(SH_ERR_WARN, FIL__, __LINE__, 0, MSG_TCP_FBAD);
    398404          sh_error_handle ((-1), FIL__, __LINE__, fd, MSG_D_FAIL);
    399405          local_file = 1;
    … …  
    490496  /* Validate signature of open file.
    491497   */
    492   if (0 != sh_gpg_check_sign (fd, 0, 1))
     498  if (0 != sh_gpg_check_sign (fd, SIG_CONF))
    493499    {
    494500      SH_FREE(line_in);
     501      sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_EXIT_ABORT1, sh.prg_name);
    495502      aud_exit (FIL__, __LINE__, EXIT_FAILURE);
    496503    }
    … …  
    830837}
    831838
     839
     840#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
     841static int sh_readconf_set_delay (const char * c)
     842{
     843  unsigned long i = atol (c);
     844
     845  if (i  > INT_MAX)
     846    return -i;
     847  sh.delayload = (int) i;
     848  return 0;
     849}
     850#endif
     851
    832852#ifdef FANCY_LIBCAP
    833853int sh_readconf_setCaps(const char * c)
    … …  
    965985    sh_files_pushfile_prelink },
    966986
    967   { N_("ignoreadded"),   SH_SECTION_MISC,   SH_SECTION_NONE,
     987  { N_("ignoreadded"),          SH_SECTION_MISC,   SH_SECTION_NONE,
    968988    sh_ignore_add_new },
    969   { N_("ignoremissing"), SH_SECTION_MISC,   SH_SECTION_NONE,
     989  { N_("ignoremissing"),        SH_SECTION_MISC,   SH_SECTION_NONE,
    970990    sh_ignore_add_del },
    971   { N_("ignoremodified"), SH_SECTION_MISC,   SH_SECTION_NONE,
     991  { N_("ignoremodified"),       SH_SECTION_MISC,   SH_SECTION_NONE,
    972992    sh_ignore_add_mod },
    973993
    974   { N_("skipchecksum"),  SH_SECTION_MISC,   SH_SECTION_NONE,
     994  { N_("skipchecksum"),         SH_SECTION_MISC,   SH_SECTION_NONE,
    975995    sh_restrict_define },
    976   { N_("filetype"),      SH_SECTION_MISC,   SH_SECTION_NONE,
     996  { N_("filetype"),             SH_SECTION_MISC,   SH_SECTION_NONE,
    977997    sh_restrict_add_ftype },
    978998
    … …  
    9831003    sh_set_schedule_two },
    9841004
    985   { N_("usehardlinkcheck"),   SH_SECTION_MISC,   SH_SECTION_NONE,
     1005  { N_("usehardlinkcheck"),     SH_SECTION_MISC,   SH_SECTION_NONE,
    9861006    sh_files_check_hardlinks },
    987   { N_("usersrccheck"),       SH_SECTION_MISC,   SH_SECTION_NONE,
     1007  { N_("usersrccheck"),         SH_SECTION_MISC,   SH_SECTION_NONE,
    9881008    sh_files_use_rsrc },
    989   { N_("hardlinkoffset"),     SH_SECTION_MISC,   SH_SECTION_NONE,
     1009  { N_("hardlinkoffset"),       SH_SECTION_MISC,   SH_SECTION_NONE,
    9901010    sh_files_hle_reg },
    9911011#if defined(USE_XATTR)
    992   { N_("useselinuxcheck"),    SH_SECTION_MISC,   SH_SECTION_NONE,
     1012  { N_("useselinuxcheck"),      SH_SECTION_MISC,   SH_SECTION_NONE,
    9931013    sh_unix_setcheckselinux },
    9941014#endif
    9951015#if defined(USE_ACL)
    996   { N_("useaclcheck"),        SH_SECTION_MISC,   SH_SECTION_NONE,
     1016  { N_("useaclcheck"),          SH_SECTION_MISC,   SH_SECTION_NONE,
    9971017    sh_unix_setcheckacl },
    9981018#endif
    999   { N_("loosedircheck"),      SH_SECTION_MISC,   SH_SECTION_NONE,
     1019  { N_("loosedircheck"),        SH_SECTION_MISC,   SH_SECTION_NONE,
    10001020    sh_hash_loosedircheck },
    1001   { N_("addokchars"),         SH_SECTION_MISC,   SH_SECTION_NONE,
     1021  { N_("addokchars"),           SH_SECTION_MISC,   SH_SECTION_NONE,
    10021022    sh_util_obscure_ok },
    1003   { N_("filenamesareutf8"),   SH_SECTION_MISC,   SH_SECTION_NONE,
     1023  { N_("filenamesareutf8"),     SH_SECTION_MISC,   SH_SECTION_NONE,
    10041024    sh_util_obscure_utf8 },
    1005   { N_("setrecursionlevel"),  SH_SECTION_MISC,   SH_SECTION_NONE,
     1025  { N_("setrecursionlevel"),    SH_SECTION_MISC,   SH_SECTION_NONE,
    10061026    sh_files_setrecursion },
    1007   { N_("checksumtest"),       SH_SECTION_MISC,   SH_SECTION_NONE,
     1027  { N_("checksumtest"),         SH_SECTION_MISC,   SH_SECTION_NONE,
    10081028    sh_util_setchecksum },
    1009   { N_("reportonlyonce"),     SH_SECTION_MISC,   SH_SECTION_NONE,
     1029  { N_("reportonlyonce"),       SH_SECTION_MISC,   SH_SECTION_NONE,
    10101030    sh_files_reportonce },
    1011   { N_("reportfulldetail"),   SH_SECTION_MISC,   SH_SECTION_NONE,
     1031  { N_("reportfulldetail"),     SH_SECTION_MISC,   SH_SECTION_NONE,
    10121032    sh_files_fulldetail },
    1013   { N_("uselocaltime"),       SH_SECTION_MISC,   SH_SECTION_NONE,
     1033  { N_("uselocaltime"),         SH_SECTION_MISC,   SH_SECTION_NONE,
    10141034    sh_unix_uselocaltime },
    10151035
    1016   { N_("setnicelevel"),   SH_SECTION_MISC,   SH_SECTION_NONE,
     1036  { N_("setnicelevel"),         SH_SECTION_MISC,   SH_SECTION_NONE,
    10171037    sh_readconf_set_nice },
    10181038
     1039  { N_("startuploaddelay"),     SH_SECTION_MISC,   SH_SECTION_NONE,
     1040    sh_readconf_set_delay },
     1041
    10191042#if defined(FANCY_LIBCAP)
    1020   { N_("usecaps"),        SH_SECTION_MISC,   SH_SECTION_NONE,
     1043  { N_("usecaps"),              SH_SECTION_MISC,   SH_SECTION_NONE,
    10211044    sh_readconf_setCaps },
    10221045#endif
    10231046
    1024   { N_("setdropcache"),   SH_SECTION_MISC,   SH_SECTION_NONE,
     1047  { N_("reportcheckflags"),     SH_SECTION_MISC,   SH_SECTION_NONE,
     1048    set_report_checkflags },
     1049
     1050  { N_("setdropcache"),         SH_SECTION_MISC,   SH_SECTION_NONE,
    10251051    sl_set_drop_cache },
    10261052
    1027   { N_("setiolimit"),   SH_SECTION_MISC,   SH_SECTION_NONE,
     1053  { N_("setiolimit"),           SH_SECTION_MISC,   SH_SECTION_NONE,
    10281054    sh_unix_set_io_limit },
    10291055
    10301056  { N_("versionstring"),        SH_SECTION_MISC,   SH_SECTION_NONE,
    1031     sh_hash_version_string },
     1057    sh_dbIO_version_string },
    10321058
    10331059  { N_("digestalgo"),           SH_SECTION_MISC,   SH_SECTION_NONE,
    … …  
    10921118    sh_socket_password },
    10931119  { N_("setstripdomain"),      SH_SECTION_SRV,  SH_SECTION_MISC,
    1094     sh_forward_set_strip },
     1120    sh_xfer_set_strip },
    10951121  { N_("useseparatelogs"),     SH_SECTION_SRV,  SH_SECTION_MISC,
    10961122    set_flag_sep_log },
    … …  
    10981124    sh_unix_set_chroot },
    10991125  { N_("setclienttimelimit"),  SH_SECTION_SRV,  SH_SECTION_MISC,
    1100     sh_forward_set_time_limit },
     1126    sh_xfer_set_time_limit },
    11011127  { N_("setconnectiontimeout"),SH_SECTION_SRV,  SH_SECTION_MISC,
    1102     sh_forward_set_timeout },
     1128    sh_xfer_set_timeout },
    11031129  { N_("useclientseverity"),   SH_SECTION_SRV,  SH_SECTION_MISC,
    1104   sh_forward_use_clt_sev },
     1130  sh_xfer_use_clt_sev },
    11051131  { N_("useclientclass"),      SH_SECTION_SRV,  SH_SECTION_MISC,
    1106   sh_forward_use_clt_class },
     1132  sh_xfer_use_clt_class },
    11071133  { N_("severitylookup"),      SH_SECTION_SRV,  SH_SECTION_MISC,
    1108   sh_forward_lookup_level },
     1134  sh_xfer_lookup_level },
    11091135  { N_("setclientfromaccept"), SH_SECTION_SRV,  SH_SECTION_MISC,
    11101136    set_socket_peer },
    11111137  { N_("setserverport"),       SH_SECTION_SRV,  SH_SECTION_MISC,
    1112     sh_forward_set_port },
     1138    sh_xfer_set_port },
    11131139  { N_("setserverinterface"),  SH_SECTION_SRV,  SH_SECTION_MISC,
    1114     sh_forward_set_interface },
     1140    sh_xfer_set_interface },
    11151141  { N_("client"),              SH_SECTION_CLIENTS,           SH_SECTION_NONE,
    1116     sh_forward_register_client },
     1142    sh_xfer_register_client },
    11171143#endif
    11181144
    … …  
    11241150#if defined(SH_WITH_SERVER)
    11251151  { N_("setlogserver"),        SH_SECTION_SRV,  SH_SECTION_MISC,
    1126     sh_forward_setlogserver },
     1152    sh_xfer_set_logserver },
    11271153#else
    11281154  { N_("setlogserver"),        SH_SECTION_CLT,  SH_SECTION_MISC,
    1129     sh_forward_setlogserver },
     1155    sh_xfer_set_logserver },
    11301156  { N_("setthrottle"),         SH_SECTION_CLT,  SH_SECTION_MISC,
    1131     sh_forward_set_throttle_delay},
     1157    sh_xfer_set_throttle_delay},
     1158  { N_("setdeltaretrycount"),   SH_SECTION_CLT,  SH_SECTION_MISC,
     1159    set_delta_retry_count},
     1160  { N_("setdeltaretryinterval"),SH_SECTION_CLT,  SH_SECTION_MISC,
     1161    set_delta_retry_interval},
    11321162#endif
    11331163#endif
    … …  
    12741304  char * key;
    12751305  const char * value;
     1306  char * value_dup;
    12761307  char * tmp;
    12771308  int    i;
    … …  
    13941425   * If !defined(SH_EVAL_SHELL), this will reduce to a strdup.
    13951426   */
    1396   value = sh_readconf_expand_value(value);
    1397 
    1398   if (!value || (*value) == '\0')
    1399     {
    1400       TPT(( 0, FIL__, __LINE__, _("msg=<ConfigFile: empty after shell expansion: %s>\n"),
     1427  value_dup = sh_readconf_expand_value(value);
     1428
     1429  if (!value_dup || (*value_dup) == '\0')
     1430    {
     1431      TPT(( 0, FIL__, __LINE__,
     1432            _("msg=<ConfigFile: empty after shell expansion: %s>\n"),
    14011433            line));
    14021434      SL_RETURN(good_opt, _("sh_readconf_line"));
    14031435    }
     1436
     1437  value = value_dup;
    14041438
    14051439#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
    … …  
    14671501    }
    14681502
    1469   SH_FREE((char*)value);
     1503  SH_FREE(value_dup);
    14701504
    14711505  SL_RETURN(good_opt, _("sh_readconf_line"));
    14721506}
    1473  
     1507
    14741508   

  • trunk/src/sh_registry.c

    r422 r481  
    889889      size_t  tlen    = sl_strlen(tmp);
    890890
    891       if (SL_TRUE == sl_ok_adds(64, tlen))
     891      if (S_TRUE == sl_ok_adds(64, tlen))
    892892        {
    893893          char * errbuf;
    … …  
    905905                               0, NULL );
    906906
    907           if (elen > 0 && SL_TRUE == sl_ok_adds(elen, tlen))
     907          if (elen > 0 && S_TRUE == sl_ok_adds(elen, tlen))
    908908            {
    909909              tlen += elen;
    … …  
    978978      size_t tlen = sl_strlen(tmp);
    979979
    980       if (SL_TRUE == sl_ok_adds(64, tlen))
     980      if (S_TRUE == sl_ok_adds(64, tlen))
    981981        {
    982982          char * errbuf = SH_ALLOC(64 + tlen);

  • trunk/src/sh_schedule.c

    r454 r481  
    5555#include "samhain.h"
    5656#include "sh_mem.h"
     57#include "sh_error_min.h"
    5758
    5859/* TESTONLY */
    … …  
    143144  tval = localtime(&now);
    144145#endif
     146
     147  if (!tval)
     148    {
     149      sh_error_handle ((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
     150                       _("localime() failed"), _("test_sched_int") );
     151      return 0;
     152    }
     153
    145154  count = 0;
    146155  for (i = 0; i < 5; ++i)

  • trunk/src/sh_socket.c

    r421 r481  
    3333#include <string.h>
    3434
     35#if TIME_WITH_SYS_TIME
     36#include <sys/time.h>
     37#include <time.h>
     38#else
     39#if HAVE_SYS_TIME_H
     40#include <sys/time.h>
     41#else
     42#include <time.h>
     43#endif
     44#endif
     45
    3546#include "samhain.h"
    3647#include "sh_socket.h"
    … …  
    3849#include "sh_unix.h"
    3950#include "sh_calls.h"
     51#include "sh_guid.h"
     52#include "sh_fifo.h"
     53#include "sh_utils.h"
    4054
    4155#undef  FIL__
    … …  
    4660#include <signal.h>
    4761
     62typedef struct delta_tofetch {
     63  char            uuid[SH_UUID_BUF];
     64  time_t          last_time;
     65  unsigned int    count;
     66} SH_DELTA_DB;
     67
     68static SH_DELTA_DB * parse_entry(SH_DELTA_DB * db, const char * str)
     69{
     70  long last_time;
     71  unsigned int count;
     72  char buf[SH_UUID_BUF];
     73  int res = sscanf(str, _("%u:%ld:%36s"), &count, &last_time, buf);
     74  if (res == 3)
     75    {
     76      db->count = count;
     77      db->last_time  = (time_t) last_time;
     78      sl_strlcpy(db->uuid, buf, SH_UUID_BUF);
     79      return db;
     80    }
     81  return NULL;
     82}
     83
     84static char * unparse_entry(const SH_DELTA_DB * db, char * str, size_t len)
     85{
     86  int nbytes = sl_snprintf(str, len, _("%u:%ld:%s"),
     87                           db->count, (long) db->last_time, db->uuid);
     88  if (nbytes < 0 || nbytes >= (int) len)
     89    return NULL;
     90  return str;
     91}
     92
     93static SH_FIFO xfifo = SH_FIFO_INITIALIZER;
     94
     95int sh_socket_store_uuid(const char * cmd)
     96{
     97  char * p = sh_util_strdup(cmd);
     98  char * q = strchr(cmd, ':');
     99  char   entry[SH_BUFSIZE];
     100  SH_DELTA_DB db;
     101
     102  if (!q) { SH_FREE(p); return -1; }
     103
     104  ++q;
     105
     106  if (0 != sh_uuid_check(q)) { SH_FREE(p); return -1; }
     107
     108  db.count = 0;
     109  db.last_time = (time_t) 0;
     110  sl_strlcpy(db.uuid, q, SH_UUID_BUF);
     111  SH_FREE(p);
     112
     113  if (NULL != unparse_entry(&db, entry, sizeof(entry)))
     114    {
     115      sh_fifo_push(&xfifo, entry);
     116      return 0;
     117    }
     118  return -1;
     119}
     120
     121static unsigned int try_interval = 60;
     122static unsigned int try_max = 2;
     123
     124int set_delta_retry_interval(const char * str)
     125{
     126  long val = strtol (str, (char **)NULL, 10);
     127
     128  if (val < 0 || val > INT_MAX)
     129    return -1;
     130  try_interval = (unsigned int) val;
     131  return 0;
     132}
     133int set_delta_retry_count(const char * str)
     134{
     135  long val = strtol (str, (char **)NULL, 10);
     136
     137  if (val < 0 || val > INT_MAX)
     138    return -1;
     139  try_max = (unsigned int) val;
     140  return 0;
     141}
     142
     143char * sh_socket_get_uuid(int * errflag, unsigned int * count, time_t * last)
     144{
     145  char * entry = sh_fifo_pop(&xfifo);
     146  char * uuid = NULL;
     147
     148  if (entry)
     149    {
     150      SH_DELTA_DB db;
     151      time_t      now;
     152     
     153      if (NULL == parse_entry(&db, entry))
     154        {
     155          SH_FREE(entry);
     156          sh_error_handle(SH_ERR_WARN, FIL__, __LINE__, 0, MSG_E_SUBGEN,
     157                          _("Bad entry in fifo"),
     158                          _("sh_socket_get_uuid"));
     159          *errflag = -1;
     160          return NULL;
     161        }
     162
     163      now = time(NULL);
     164
     165      if ( (db.count > 0) && ((unsigned long)(now - db.last_time) < try_interval) )
     166        {
     167          sh_fifo_push_tail(&xfifo, entry);
     168          SH_FREE(entry);
     169          *errflag = -1;
     170          return NULL;
     171        }
     172
     173      SH_FREE(entry);
     174      uuid   = sh_util_strdup(db.uuid);
     175      *count = db.count;
     176      *last  = db.last_time;
     177    }
     178
     179  *errflag = 0;
     180  return uuid;
     181}
     182
     183int sh_socket_return_uuid (const char * uuid, unsigned int count, time_t last)
     184{
     185  (void) last;
     186
     187  if (count < try_max)
     188    {
     189      char   entry[SH_BUFSIZE];
     190      SH_DELTA_DB db;
     191      time_t now = time(NULL);
     192
     193      db.count     = count + 1;
     194      db.last_time = now;
     195      sl_strlcpy(db.uuid, uuid, SH_UUID_BUF);
     196
     197      if (NULL != unparse_entry(&db, entry, sizeof(entry)))
     198        return sh_fifo_push_tail(&xfifo, entry); /* >0 for success */
     199    }
     200  return -1;
     201}
     202
    48203void sh_socket_server_cmd(const char * srvcmd)
    49204{
    … …  
    54209      SL_RET0(_("sh_socket_server_cmd"));
    55210    }
    56   if ((srvcmd[0] == 'S') && (srvcmd[1] == 'T') &&
    57       (srvcmd[2] == 'O') && (srvcmd[3] == 'P'))
     211
     212  if (0 == strncmp(srvcmd, _("STOP"), 4))
    58213    {
    59214      TPT((0, FIL__, __LINE__, _("msg=<stop command from server>\n")));
    … …  
    65220#endif
    66221    }
    67   else if ((srvcmd[0] == 'R') && (srvcmd[1] == 'E') &&
    68            (srvcmd[2] == 'L') && (srvcmd[3] == 'O') &&
    69            (srvcmd[4] == 'A') && (srvcmd[5] == 'D'))
     222
     223  else if (0 == strncmp(srvcmd, _("RELOAD"), 6))
    70224    {
    71225      TPT((0, FIL__, __LINE__, _("msg=<reload command from server>\n")));
    … …  
    77231#endif
    78232    }
    79   else if ((srvcmd[0] == 'S') && (srvcmd[1] == 'C') &&
    80            (srvcmd[2] == 'A') && (srvcmd[3] == 'N'))
     233
     234  else if (0 == strncmp(srvcmd, _("DELTA:"), 6))
     235    {
     236      TPT((0, FIL__, __LINE__, _("msg=<delta load command from server>\n")));
     237
     238      if (sh_socket_store_uuid(srvcmd) == 0)
     239        {
     240          ++sh_load_delta_flag;
     241          ++sig_raised;
     242        }
     243    }
     244
     245  else if (0 == strncmp(srvcmd, _("SCAN"), 4))
    81246    {
    82247      TPT((0, FIL__, __LINE__, _("msg=<scan command from server>\n")));
    83       if (sh.flag.isdaemon == ON)
     248      if (sh.flag.isdaemon == S_TRUE)
    84249        {
    85250#ifdef SIGTTOU
    … …  
    96261        }
    97262    }
     263
     264  /* Unknown command
     265   */
    98266  else
    99267    {
    100       sh_error_handle(SH_ERR_INFO, FIL__, __LINE__, 0, MSG_E_SUBGEN,
     268      sh_error_handle(SH_ERR_WARN, FIL__, __LINE__, 0, MSG_E_SUBGEN,
    101269                      srvcmd,
    102270                      _("sh_socket_server_cmd"));
    … …  
    104272  SL_RET0(_("sh_socket_server_cmd"));
    105273}
    106 /* #if defined (SH_WITH_CLIENT)
    107  */
    108 #endif
     274#endif  /* #if defined (SH_WITH_CLIENT) */
    109275
    110276#if defined(SH_WITH_SERVER)
    … …  
    225391  struct stat buf;
    226392
    227 #ifdef SH_DEBUG_SOCKET
    228   fprintf(stderr, "PROBE\n");
    229 #endif
    230 
    231393  for (item = (client_t *) zAVLFirst(&avlcursor, all_clients); item;
    232394       item = (client_t *) zAVLNext(&avlcursor))
    233395    {
    234 #ifdef SH_DEBUG_SOCKET
    235       fprintf(stderr, "%s %d\n", item->hostname, (int)item->status_now);
    236 #endif
    237 
    238396      if (item->status_now != CLT_INACTIVE)
    239397        {
    … …  
    242400          file = get_client_conf_file (item->hostname, &dummy);
    243401
    244 #ifdef SH_DEBUG_SOCKET
    245           fprintf(stderr, "%s\n", file);
    246 #endif
    247402          if (0 == stat (file, &buf))
    248403            {
    … …  
    250405              while (new)
    251406                {
    252 #ifdef SH_DEBUG_SOCKET
    253                   fprintf(stderr, "%s <> %s\n", new->clt, item->hostname);
    254 #endif
    255407                  if (0 == sl_strcmp(new->clt, item->hostname))
    256408                    {
    257409                      flag = 1; /* Client is in list already */
    258410
    259 #ifdef SH_DEBUG_SOCKET
    260                       fprintf(stderr, "%lu <> %lu\n",
    261                               (unsigned long) buf.st_mtime,
    262                               (unsigned long)new->cti);
    263 #endif
    264411                      if (buf.st_mtime > new->cti)
    265412                        {
    … …  
    368515
    369516#define NEED_PASSWORD_AUTH
    370 
    371517#endif
    372518
    … …  
    540686  SL_RETURN( (0), _("sh_socket_open_int"));
    541687}
    542 /* #if !defined(HAVE_CMSGCRED) || !defined(SO_PEERCRED) */
    543 /* #endif */
    544 
    545 /*
    546 #if !defined(HAVE_GETPEEREID) && !defined(SO_PEERCRED) && !defined(HAVE_STRUCT_CMSGCRED) && !defined(HAVE_STRUCT_FCRED) && !(defined(HAVE_STRUCT_SOCKCRED) && defined(LOCAL_CREDS))
    547 static
    548 int sh_socket_read (struct socket_cmd * srvcmd)
    549 {
    550   srvcmd->cmd[0] = '\0';
    551   srvcmd->clt[0] = '\0';
    552   return 0;
    553 }
    554 #else
    555 */
     688
    556689
    557690/*
    … …  
    582715 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
    583716 */
    584 static
    585 int sh_socket_read (struct socket_cmd * srvcmd)
    586 {
    587   struct socket_cmd * list_cmd;
    588   char message[SH_MAXMSG];
    589   struct sockaddr_un name;
    590   ACCEPT_TYPE_ARG3 size = sizeof(name);
    591 
     717
     718static int receive_message(int talkfd, struct msghdr * msg, size_t message_size)
     719{
     720  unsigned int retry = 0;
    592721  int nbytes;
    593   int talkfd;
    594   int retry = 0;
    595 
    596   char * cmd = NULL;
    597   char * clt = NULL;
    598 
    599   int  client_uid = -1;
     722  char * message = msg->msg_iov->iov_base;
    600723  char errbuf[SH_ERRBUF_SIZE];
    601724
    602 
    603   struct msghdr msg;
    604   struct iovec iov;
    605 
    606 #if defined(NEED_PASSWORD_AUTH)
    607   char * eopw = NULL;
    608   char * goodpassword = NULL;
    609 #endif
    610 
    611 #if defined(HAVE_GETPEEREID)
    612   uid_t peer_uid;
    613   gid_t peer_gid;
    614 #elif defined(SO_PEERCRED)
    615   struct ucred cr;
    616 #ifdef HAVE_SOCKLEN_T
    617   socklen_t cl = sizeof(cr);
    618 #else
    619   int       cl = sizeof(cr);
    620 #endif
    621 
    622 #elif defined(HAVE_STRUCT_CMSGCRED) || defined(HAVE_STRUCT_FCRED) || (defined(HAVE_STRUCT_SOCKCRED) && defined(LOCAL_CREDS))
    623 
    624 #ifdef HAVE_STRUCT_CMSGCRED
    625   typedef struct cmsgcred Cred;
    626 #define CRED_UID cmcred_uid
    627 
    628 #elif HAVE_STRUCT_FCRED
    629   typedef struct fcred Cred;
    630 #define CRED_UID fc_uid
    631 
    632 #elif HAVE_STRUCT_SOCKCRED
    633   typedef struct sockcred Cred;
    634 #define CRED_UID sc_uid
    635 
    636 #endif
    637   Cred       *cred;
    638 
    639   /* Compute size without padding */
    640   char   cmsgmem[ALIGN(sizeof(struct cmsghdr)) + ALIGN(sizeof(Cred))];   
    641   /* for NetBSD */
    642 
    643   /* Point to start of first structure */
    644   struct cmsghdr *cmsg = (struct cmsghdr *) cmsgmem;
    645 #endif
    646 
    647   if (pf_unix_fd  < 0)
    648     {
    649       return 0;
    650     }
    651 
    652   iov.iov_base = (char *) &message;
    653   iov.iov_len  = sizeof(message);
    654 
    655   memset (&msg, 0, sizeof (msg));
    656   msg.msg_iov = &iov;
    657   msg.msg_iovlen = 1;
    658 
    659 #if !defined(SO_PEERCRED) && !defined(HAVE_GETPEEREID)
    660 #if defined(HAVE_STRUCT_CMSGCRED) || defined(HAVE_STRUCT_FCRED) || (defined(HAVE_STRUCT_SOCKCRED) && defined(LOCAL_CREDS))
    661   msg.msg_control = (char *) cmsg;
    662   msg.msg_controllen = sizeof (cmsgmem);
    663   memset (cmsg, 0, sizeof (cmsgmem));
    664 #endif
    665 #endif
    666 
    667   /* the socket is non-blocking
    668    * 'name' is the address of the sender socket
    669    */
    670725  do {
    671     talkfd = accept(pf_unix_fd, (struct sockaddr *) &name, &size);
    672   } while (talkfd < 0 && errno == EINTR);
    673 
    674   if ((talkfd < 0) && (errno == EAGAIN))
    675     {
    676       return 0;
    677     }
    678   else if (talkfd < 0)
    679     {
    680       sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    681                       sh_error_message (errno, errbuf, sizeof(errbuf)),
    682                       _("sh_socket_read: accept"));
    683       return -1;
    684     }
    685 
    686 
    687 #if defined(LOCAL_CREDS) && !defined(SO_PEERCRED) && !defined(HAVE_GETPEEREID)
    688   /* Set the socket to receive credentials on the next message
    689    */
    690   {
    691     int on = 1;
    692     if (setsockopt (talkfd, 0, LOCAL_CREDS, &on, sizeof (on)) < 0)
    693       {
    694         sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    695                         sh_error_message (errno, errbuf, sizeof(errbuf)),
    696                         _("sh_socket_read: setsockopt"));
    697         sl_close_fd(FIL__, __LINE__, talkfd);
    698         return -1;
    699       }
    700   }
    701 #endif
    702 
    703   do {
    704     nbytes = recvmsg (talkfd, &msg, 0);
     726    nbytes = recvmsg (talkfd, msg, 0);
    705727    if ((nbytes < 0) && (errno != EAGAIN))
    706728      {
    … …  
    718740  } while ((nbytes < 0) && (retry < 3));
    719741
    720 #ifdef SH_DEBUG_SOCKET
    721   fprintf(stderr, "%d bytes received\n", nbytes);
    722 #endif
    723 
    724742  /* msg.msg_iov.iov_base, filled by recvmsg
    725743   */
    726   message[sizeof(message)-1] = '\0';
     744  message[message_size-1] = '\0';
    727745
    728746  if (nbytes < 0)
    … …  
    731749        {
    732750          /* no data */
     751          sh_error_handle(SH_ERR_ALL, FIL__, __LINE__, errno, MSG_E_SUBGEN,
     752                          sh_error_message (errno, errbuf, sizeof(errbuf)),
     753                          _("sh_socket_read: recvfrom"));
    733754          sl_close_fd(FIL__, __LINE__, talkfd);
    734755          return 0;
    … …  
    740761      return -1;
    741762    }
     763  return 0;
     764}
    742765
    743766#if defined(HAVE_GETPEEREID)
     767
     768static int get_peer_uid(int talkfd)
     769{
     770  uid_t peer_uid;
     771  gid_t peer_gid;
     772  char errbuf[SH_ERRBUF_SIZE];
     773
    744774  if (0 != getpeereid(talkfd, &peer_uid, &peer_gid))
    745775    {
    … …  
    750780      return -1;
    751781    }
    752   client_uid = peer_uid;
    753   cmd = message;
    754 #elif defined(SO_PEERCRED)
     782  return peer_uid;
     783}
     784
     785#elif defined(SO_PEERCRED)
     786
     787static int get_peer_uid(int talkfd)
     788{
     789  char errbuf[SH_ERRBUF_SIZE];
     790  struct ucred cr;
     791#ifdef HAVE_SOCKLEN_T
     792  socklen_t cl = sizeof(cr);
     793#else
     794  int       cl = sizeof(cr);
     795#endif
     796
    755797  if (0 != getsockopt(talkfd, SOL_SOCKET, SO_PEERCRED, &cr, &cl))
    756798    {
    … …  
    761803      return -1;
    762804    }
    763   client_uid = cr.uid;
    764   cmd = message;
    765 #elif defined(HAVE_STRUCT_CMSGCRED) || defined(HAVE_STRUCT_FCRED) || (defined(HAVE_STRUCT_SOCKCRED) && defined(LOCAL_CREDS))
    766   if (cmsg->cmsg_len < sizeof (cmsgmem) || cmsg->cmsg_type != SCM_CREDS)
    767     {
    768       sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
    769                       _("Message from recvmsg() was not SCM_CREDS"),
    770                       _("sh_socket_read"));
    771 
    772       /* Check for file descriptors sent using SCM_RIGHTS, and
    773        * close them. If MSG_CTRUNC is set, the buffer was too small,
    774        * and no fds are duped.
    775        */
    776       if (msg.msg_controllen >= sizeof(struct cmsghdr) &&
    777           (msg.msg_flags & MSG_CTRUNC) == 0)
    778         {
    779           unsigned int     data_size;
    780           unsigned int     data_i;
    781           int              fdcount, fdmax;
    782           struct cmsghdr * cmptr;
    783           int              fdsbuf[1 + (sizeof(cmsgmem)/sizeof(int))];
    784 
    785           for (cmptr = CMSG_FIRSTHDR(&msg); cmptr != NULL;
    786                cmptr = CMSG_NXTHDR(&msg, cmptr))
    787             {
    788               if (cmptr->cmsg_len > sizeof (cmsgmem) ||
    789                   cmptr->cmsg_level != SOL_SOCKET ||
    790                   cmptr->cmsg_type  != SCM_RIGHTS)
    791                 continue;
    792 
    793               /* Crappy way of finding the data length.
    794                * cmptr->cmsg_len includes both header and padding,
    795                * how are you supposed to find the data length?
    796                * cmptr->cmsg_len - ALIGN(sizeof(struct cmsghdr)) ?
    797                */
    798               data_size = 0;
    799 
    800               for (data_i = 0; data_i < cmptr->cmsg_len; ++data_i)
    801                 {
    802                   if (CMSG_LEN(data_i) == cmptr->cmsg_len)
    803                     {
    804                       data_size = data_i;
    805                       break;
    806                     }
    807                 }
    808               memcpy(fdsbuf, CMSG_DATA(cmptr), data_size);
    809               fdmax = data_size / sizeof(int);
    810               for (fdcount = 0; fdcount < fdmax; ++fdcount)
    811                 (void) sl_close_fd(FIL__, __LINE__, fdsbuf[fdcount]);
    812             }
    813         }
    814      
    815       sl_close_fd(FIL__, __LINE__, talkfd);
    816       return -1;
    817     }
    818   cred = (Cred *) CMSG_DATA (cmsg);
    819   client_uid = cred->CRED_UID;
    820   cmd = message;
    821 #elif defined(NEED_PASSWORD_AUTH)
     805  return cr.uid;
     806}
     807
     808#endif
     809
     810#if defined(NEED_PASSWORD_AUTH)
     811char * check_password(char * message, int * client_uid, int talkfd)
     812{
     813  char * cmd = NULL;
     814  char * eopw = NULL;
     815  char * goodpassword = NULL;
     816
    822817  goodpassword = sh_get_sockpass();
    823818  eopw = strchr(message, '@');
    … …  
    830825      strlen(goodpassword) < (sizeof(message)/2))
    831826    {
    832       client_uid = sh_socket_flaguid;
     827      *client_uid = sh_socket_flaguid;
    833828      cmd = &message[strlen(goodpassword)+1];
    834829      sh_set_sockpass();
    … …  
    841836      sh_set_sockpass();
    842837      sl_close_fd(FIL__, __LINE__, talkfd);
     838      return NULL;
     839    }
     840  return cmd;
     841}
     842#endif
     843
     844static int list_all (int talkfd, char * cmd);
     845static int process_message(int talkfd, char * cmd, struct socket_cmd * srvcmd);
     846
     847static
     848int sh_socket_read (struct socket_cmd * srvcmd)
     849{
     850  char message[SH_MAXMSG];
     851  struct sockaddr_un name;
     852  ACCEPT_TYPE_ARG3 size = sizeof(name);
     853  int talkfd;
     854  char * cmd = NULL;
     855  int  client_uid = -1;
     856  char errbuf[SH_ERRBUF_SIZE];
     857  struct msghdr msg;
     858  struct iovec iov;
     859  int status;
     860
     861  if (pf_unix_fd  < 0)
     862    return 0;
     863
     864  iov.iov_base = (char *) &message;
     865  iov.iov_len  = sizeof(message);
     866
     867  memset (&msg, 0, sizeof (msg));
     868  msg.msg_iov = &iov;
     869  msg.msg_iovlen = 1;
     870
     871  /* the socket is non-blocking
     872   * 'name' is the address of the sender socket
     873   */
     874  do {
     875    talkfd = accept(pf_unix_fd, (struct sockaddr *) &name, &size);
     876  } while (talkfd < 0 && errno == EINTR);
     877
     878  if ((talkfd < 0) && (errno == EAGAIN))
     879    {
     880      return 0;
     881    }
     882  else if (talkfd < 0)
     883    {
     884      sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
     885                      sh_error_message (errno, errbuf, sizeof(errbuf)),
     886                      _("sh_socket_read: accept"));
    843887      return -1;
    844888    }
     889
     890  if (receive_message(talkfd, &msg, sizeof(message)) < 0)
     891    return -1;
     892
     893  /* Authenticate request by peer uid or password.
     894   */
     895#if defined(HAVE_GETPEEREID)
     896  client_uid = get_peer_uid(talkfd);
     897  cmd = message;
     898
     899#elif defined(SO_PEERCRED)
     900  client_uid = get_peer_uid(talkfd);
     901  cmd = message;
     902
     903#elif defined(NEED_PASSWORD_AUTH)
     904  cmd = check_password(message, &client_uid, talkfd);
     905
    845906#else
    846907  sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    … …  
    851912#endif
    852913
    853 #ifdef SH_DEBUG_SOCKET
    854   fprintf(stderr, "Peer uid=%d, required=%d\n",
    855           client_uid, sh_socket_flaguid);
    856 #endif
    857 
    858914  if (client_uid != sh_socket_flaguid)
    859915    {
    … …  
    865921    }
    866922
    867 
    868   /* Give a diagnostic message.
    869    */
    870 #ifdef SH_DEBUG_SOCKET
    871   fprintf (stderr, "Server: got message: %s\n", cmd);
    872 #endif
    873 
    874   clt = strchr(cmd, ':');
     923  status = process_message(talkfd, cmd, srvcmd);
     924
     925  sl_close_fd(FIL__, __LINE__, talkfd);
     926  return status;
     927}
     928
     929static int check_valid_command(const char * str)
     930{
     931  unsigned int i = 0;
     932  char * commands[] = { N_("DELTA"),  N_("RELOAD"),  N_("STOP"), N_("SCAN"),
     933                        N_("CANCEL"), N_("LISTALL"), N_("LIST"), N_("PROBE"), NULL };
     934
     935  while (commands[i])
     936    {
     937      if (0 == strcmp(_(commands[i]), str))
     938        {
     939          return 0;
     940        }
     941      ++i;
     942    }
     943  return -1;
     944}
     945
     946static int send_reply (int fd, char * msg)
     947{
     948  int nbytes = send (fd, msg, strlen(msg) + 1, 0);
     949
     950  if (nbytes < 0)
     951    {
     952      char errbuf[SH_ERRBUF_SIZE];
     953      sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
     954                      sh_error_message (errno, errbuf, sizeof(errbuf)),
     955                      _("send_reply"));
     956      return -1;
     957    }
     958
     959  return nbytes;
     960}
     961
     962static int process_message(int talkfd, char * cmd, struct socket_cmd * srvcmd)
     963{
     964  int nbytes;
     965  char error_type[SH_ERRBUF_SIZE] = { '\0' };
     966  char * clt  = (cmd) ? strchr(cmd, ':') : NULL;
     967
     968  if (clt && 0 == strncmp(cmd, _("DELTA:"), 6))
     969    {
     970      /* DELTA:uuid:hostname
     971       */
     972      char * uuid = clt;
     973     
     974      *uuid = '\0'; ++uuid;
     975      clt = strchr(uuid, ':');
     976      if (clt) { *clt = '\0'; ++clt; }
     977     
     978      if (sh_uuid_check(uuid) < 0)
     979        {
     980          sl_strlcpy(error_type, _("!E:uuid-format:"), sizeof(error_type));
     981          sl_strlcat(error_type, uuid, sizeof(error_type));
     982          clt = NULL;
     983        }
     984     
     985      --uuid; *uuid = ':';
     986    }
     987  else if (clt && *clt == ':')
     988    {
     989      *clt = '\0'; ++clt;
     990      if (check_valid_command(cmd) < 0)
     991        {
     992          sl_strlcpy(error_type, _("!E:cmd-invalid:"), sizeof(error_type));
     993          sl_strlcat(error_type, cmd, sizeof(error_type));
     994          clt = NULL;
     995        }
     996    }
     997   
    875998  if (clt != NULL)
    876999    {
    877       *clt = '\0'; ++clt;
    8781000      if (sl_strlen(cmd) >= SH_MAXMSGLEN)
    8791001        {
    880 #ifdef SH_DEBUG_SOCKET
    881           fprintf (stderr, "Server: command too long: %s\n", cmd);
    882 #endif
    8831002          sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    8841003                          _("Bad message format: command too long"),
    8851004                          _("sh_socket_read"));
    886           sl_close_fd(FIL__, __LINE__, talkfd);
     1005          sl_strlcpy(error_type, _("!E:cmd-toolong"), sizeof(error_type));
     1006          send_reply(talkfd, error_type);
    8871007          return -1;
    8881008        }
    8891009      else if (sl_strlen(clt) >= SH_MAXMSGLEN)
    8901010        {
    891 #ifdef SH_DEBUG_SOCKET
    892           fprintf (stderr, "Server: hostname too long: %s\n", clt);
    893 #endif
    8941011          sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    8951012                          _("Bad message format: hostname too long"),
    8961013                          _("sh_socket_read"));
    897           sl_close_fd(FIL__, __LINE__, talkfd);
     1014          sl_strlcpy(error_type, _("!E:hostname-toolong"), sizeof(error_type));
     1015          send_reply(talkfd, error_type);
    8981016          return -1;
    8991017        }
    900       if (cmd[0] == 'L' && cmd[1] == 'I' &&
    901           cmd[2] == 'S' && cmd[3] == 'T')
    902         {
    903 #ifdef SH_DEBUG_SOCKET
    904           fprintf (stderr, "Server: list %s\n", clt);
    905 #endif
    906           goto list_all;
    907         }
    908       else if (cmd[0] == 'P' && cmd[1] == 'R' &&
    909           cmd[2] == 'O' && cmd[3] == 'B' && cmd[4] == 'E')
    910         {
    911 #ifdef SH_DEBUG_SOCKET
    912           fprintf (stderr, "Server: probe start %s\n", clt);
    913 #endif
     1018
     1019      if (0 == strncmp(cmd, _("LIST"), 4))
     1020        return list_all(talkfd, cmd);
     1021      else if (0 == strncmp(cmd, _("PROBE"), 4))
     1022        {
    9141023          sh_socket_probe4reload();
    915 #ifdef SH_DEBUG_SOCKET
    916           fprintf (stderr, "Server: probe done  %s\n", clt);
    917 #endif
    918           cmd[0] = 'L'; cmd[1] = 'I'; cmd[2] = 'S'; cmd[3] = 'T';cmd[4] = '\0';
    919           goto list_all;
    920         }
     1024          sl_strlcpy(cmd, _("LIST"), 5);
     1025          return list_all(talkfd, cmd);
     1026        }
     1027
    9211028      sl_strlcpy (srvcmd->cmd, cmd, SH_MAXMSGLEN);
    9221029      sl_strlcpy (srvcmd->clt, clt, SH_MAXMSGLEN);
    … …  
    9251032  else
    9261033    {
    927 #ifdef SH_DEBUG_SOCKET
    928       fprintf (stderr, "Server: bad message\n");
    929 #endif
    9301034      sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    9311035                      _("Bad message format"),
    9321036                      _("sh_socket_read"));
    933       sl_close_fd(FIL__, __LINE__, talkfd);
     1037      if (error_type[0] == '\0')
     1038        sl_strlcpy(error_type, _("!E:message-format"), sizeof(error_type));
     1039      send_reply(talkfd, error_type);
    9341040      return -1;
    9351041    }
    9361042
    9371043  /* Bounce the message back to the sender.
    938    * 'name' is the receiver address; it has been been filled
    939    *        with the sender address in the recvfrom call
    9401044   */
    941 #ifdef SH_DEBUG_SOCKET
    942   fprintf (stderr, "Server: send message: %s to %s\n",
    943            cmd, name.sun_path);
    944 #endif
    945   /*
    946   nbytes = sendto (pf_unix_fd, message, nbytes, 0,
    947                        (struct sockaddr *) & name, size);
    948   */
    949   nbytes = send (talkfd, cmd, strlen(cmd) + 1, 0);
    950   sl_close_fd(FIL__, __LINE__, talkfd);
    951   if (nbytes < 0)
    952     {
    953       sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
    954                       sh_error_message (errno, errbuf, sizeof(errbuf)),
    955                       _("sh_socket_read: send"));
    956       return -1;
    957     }
    958 #ifdef SH_DEBUG_SOCKET
    959   fprintf (stderr, "Server: message is out\n");
    960 #endif
     1045  nbytes = send_reply(talkfd, cmd);
     1046
    9611047  return nbytes;
    962 
    963  list_all:
    964 #ifdef SH_DEBUG_SOCKET
    965   fprintf (stderr, "Server: list all\n");
    966 #endif
    967   if (cmd[4] == 'A' && cmd[5] == 'L' && cmd[6] == 'L')
     1048}
     1049
     1050static int list_all (int talkfd, char * cmd)
     1051{
     1052  int nbytes;
     1053  struct socket_cmd * list_cmd;
     1054  char message[SH_MAXMSG];
     1055  char errbuf[SH_ERRBUF_SIZE];
     1056
     1057  if (0 == strncmp(cmd, _("LISTALL"), 7))
    9681058    {
    9691059      list_cmd = runlist;
    9701060      while (list_cmd)
    9711061        {
    972           sl_snprintf(message, sizeof(message), _("SENT  %8s  %32s  %s"),
     1062          sl_snprintf(message, sizeof(message), _("SENT  %42s  %32s  %s"),
    9731063                      list_cmd->cmd, list_cmd->clt, list_cmd->cti);
    974           /*
    975           sl_strlcpy(message,     _("DONE"), SH_MAXMSG);
    976           sl_strlcat(message,          "  ", SH_MAXMSG);
    977           sl_strlcat(message, list_cmd->cmd, SH_MAXMSG);
    978           sl_strlcat(message,          "  ", SH_MAXMSG);
    979           sl_strlcat(message, list_cmd->clt, SH_MAXMSG);
    980           sl_strlcat(message,          "  ", SH_MAXMSG);
    981           sl_strlcat(message, list_cmd->cti, SH_MAXMSG);
    982           */
     1064
    9831065          nbytes = send (talkfd, message, sl_strlen(message) + 1, 0);
    9841066          if (nbytes < 0)
    … …  
    9871069                              sh_error_message (errno, errbuf, sizeof(errbuf)),
    9881070                              _("sh_socket_read: sendto"));
    989               sl_close_fd(FIL__, __LINE__, talkfd);
    9901071              return -1;
    9911072            }
    … …  
    9971078  while (list_cmd)
    9981079    {
    999       sl_snprintf(message, sizeof(message), _(">>>>  %8s  %32s  %s"),
     1080      sl_snprintf(message, sizeof(message), _(">>>>  %42s  %32s  %s"),
    10001081                  list_cmd->cmd, list_cmd->clt, list_cmd->cti);
    1001       /*
    1002       sl_strlcpy(message,     _(">>>>"), SH_MAXMSG);
    1003       sl_strlcat(message,          "  ", SH_MAXMSG);
    1004       sl_strlcat(message, list_cmd->cmd, SH_MAXMSG);
    1005       sl_strlcat(message,          "  ", SH_MAXMSG);
    1006       sl_strlcat(message, list_cmd->clt, SH_MAXMSG);
    1007       sl_strlcat(message,          "  ", SH_MAXMSG);
    1008       sl_strlcat(message, list_cmd->cti, SH_MAXMSG);
    1009       */
    1010       /*
    1011       nbytes = sendto (pf_unix_fd, message, sl_strlen(message) + 1, 0,
    1012                        (struct sockaddr *) & name, size);
    1013       */
     1082
    10141083      nbytes = send (talkfd, message, sl_strlen(message) + 1, 0);
    10151084      if (nbytes < 0)
    … …  
    10181087                          sh_error_message (errno, errbuf, sizeof(errbuf)),
    10191088                          _("sh_socket_read: sendto"));
    1020           sl_close_fd(FIL__, __LINE__, talkfd);
    10211089          return -1;
    10221090        }
    … …  
    10241092    }
    10251093
    1026   /*
    1027   nbytes = sendto (pf_unix_fd, _("END"), 4, 0,
    1028                    (struct sockaddr *) & name, size);
    1029   */
    1030   /* nbytes = *//* never read */ send (talkfd, _("END"), 4, 0);
    1031   sl_close_fd(FIL__, __LINE__, talkfd);
     1094  send (talkfd, _("END"), 4, 0);
    10321095  return 0;
    10331096}
    1034 /* #if !defined(HAVE_CMSGCRED) || !defined(SO_PEERCRED) */
    1035 /* #endif */
    10361097
    10371098static void sh_socket_add2list (struct socket_cmd * in)
    10381099{
    1039   struct socket_cmd  * new;
    1040 
    1041   new = SH_ALLOC(sizeof(struct socket_cmd));
    1042   sl_strlcpy (new->cmd, in->cmd, sizeof(new->cmd));
    1043   sl_strlcpy (new->clt, in->clt, sizeof(new->clt));
    1044 #ifdef SH_DEBUG_SOCKET
    1045   fprintf(stderr, "add2list: time set for %s\n", new->clt);
    1046 #endif
    1047   (void) sh_unix_time(0, new->cti, sizeof(new->cti));
    1048   new->next = cmdlist;
    1049   cmdlist   = new;
    1050 
    1051   return;
    1052 }
    1053 
    1054 static void sh_socket_add2run (struct socket_cmd * in)
    1055 {
    1056   struct socket_cmd  * new = runlist;
    1057   char * client_name       = in->clt;
     1100  struct socket_cmd  * new  = cmdlist;
     1101  struct socket_cmd  * last = cmdlist;
    10581102
    10591103  while (new)
    10601104    {
    1061       if (0 == sl_strcmp(new->clt, client_name))
    1062         {
    1063           sl_strlcpy (new->cmd, in->cmd, sizeof(new->cmd));
    1064           sl_strlcpy (new->clt, in->clt, sizeof(new->clt));
    1065 #ifdef SH_DEBUG_SOCKET
    1066           fprintf(stderr, "add2run: time reset for %s\n", new->clt);
    1067 #endif
     1105      /* Only skip identical commands.
     1106       */
     1107      if (0 == sl_strcmp(new->clt,  in->clt) &&
     1108          0 == sl_strcmp(new->cmd,  in->cmd))
     1109        {
    10681110          (void) sh_unix_time(0, new->cti, sizeof(new->cti));
    10691111          return;
    … …  
    10731115
    10741116  new = SH_ALLOC(sizeof(struct socket_cmd));
    1075   sl_strlcpy (new->cmd, in->cmd, sizeof(new->cmd));
    1076   sl_strlcpy (new->clt, in->clt, sizeof(new->clt));
     1117  sl_strlcpy (new->cmd,  in->cmd,  sizeof(new->cmd));
     1118  sl_strlcpy (new->clt,  in->clt,  sizeof(new->clt));
     1119  (void) sh_unix_time(0, new->cti, sizeof(new->cti));
     1120  new->next  = NULL;
     1121
     1122  if (last)
     1123    {
     1124      while (last->next) { last = last->next; }
     1125      last->next = new;
     1126    }
     1127  else
     1128    {
     1129      cmdlist = new;
     1130    }
     1131  return;
     1132}
     1133
     1134static void sh_socket_add2run (struct socket_cmd * in)
     1135{
     1136  struct socket_cmd  * new  = runlist;
     1137  struct socket_cmd  * last = runlist;
     1138
     1139  while (new)
     1140    {
     1141      /* Only skip identical commands. First 5 will
     1142       * make all 'DELTA' identical.
     1143       */
     1144      if (0 == sl_strcmp(new->clt,  in->clt) &&
     1145          0 == sl_strncmp(new->cmd,  in->cmd, 5))
     1146        {
     1147          sl_strlcpy (new->cmd,  in->cmd,  sizeof(new->cmd));
     1148          (void) sh_unix_time(0, new->cti, sizeof(new->cti));
     1149          return;
     1150        }
     1151      new = new->next;
     1152    }
     1153
     1154  new = SH_ALLOC(sizeof(struct socket_cmd));
     1155  sl_strlcpy (new->cmd,  in->cmd,  sizeof(new->cmd));
     1156  sl_strlcpy (new->clt,  in->clt,  sizeof(new->clt));
    10771157#ifdef SH_DEBUG_SOCKET
    10781158  fprintf(stderr, "add2run: time set for %s\n", new->clt);
    10791159#endif
    10801160  (void) sh_unix_time(0, new->cti, sizeof(new->cti));
    1081   new->next = runlist;
    1082   runlist   = new;
    1083 
     1161  new->next  = NULL;
     1162
     1163  if (last)
     1164    {
     1165      while (last->next) { last = last->next; }
     1166      last->next = new;
     1167    }
     1168  else
     1169    {
     1170      runlist = new;
     1171    }
    10841172  return;
    10851173}
    … …  
    10871175
    10881176
    1089 static void sh_socket_rm2list (const char * client_name)
     1177static void sh_socket_rm2list (const char * client_name, int remove_all)
    10901178{
    10911179  struct socket_cmd * old = cmdlist;
    … …  
    10981186          if ((new == cmdlist) && (new->next == NULL))
    10991187            {
     1188              /* There is only one entry */
    11001189              cmdlist = NULL;
    11011190              SH_FREE(new);
    … …  
    11041193          else if (new == cmdlist)
    11051194            {
     1195              /* first entry: new = old = cmdlist */
    11061196              cmdlist = new->next;
    11071197              SH_FREE(new);
    1108               return;
     1198              if (remove_all == S_FALSE)
     1199                return;
     1200              old = cmdlist;
     1201              new = cmdlist;
     1202              continue;
    11091203            }
    11101204          else
    … …  
    11121206              old->next = new->next;
    11131207              SH_FREE(new);
    1114               return;
     1208              if (remove_all == S_FALSE)
     1209                return;
     1210              new = old;
    11151211            }
    11161212        }
    … …  
    11311227
    11321228  if (pf_unix_fd  < 0)
    1133     {
    1134       return 0;
    1135     }
     1229    return 0;
    11361230
    11371231  sl_strlcpy(cancel_cmd, _("CANCEL"), sizeof(cancel_cmd));
    … …  
    11401234    {
    11411235      if (0 == sl_strcmp(cmd.cmd, cancel_cmd))
    1142         {
    1143           sh_socket_rm2list  (cmd.clt);
    1144         }
     1236        sh_socket_rm2list  (cmd.clt, S_TRUE);
    11451237      else
    1146         {
    1147           sh_socket_rm2list  (cmd.clt);
    1148           sh_socket_add2list (&cmd);
    1149         }
     1238        sh_socket_add2list (&cmd);
    11501239    }
    11511240  return 0;
    … …  
    11641253      if (0 == sl_strcmp(new->clt, client_name))
    11651254        {
    1166           sl_strlcpy(out, new->cmd, sizeof(out));
     1255          sl_strlcpy(out,  new->cmd, sizeof(out));
    11671256          sh_socket_add2run (new);
    1168           sh_socket_rm2list  (client_name);
     1257          sh_socket_rm2list (client_name, S_FALSE);
    11691258          return out;
    11701259        }
    … …  
    11731262  return NULL;
    11741263}
    1175 
    11761264/* #if defined (SH_WITH_SERVER)
    11771265 */
    11781266#endif
    11791267
     1268
     1269#ifdef SH_CUTEST
     1270#include "CuTest.h"
     1271
     1272void Test_cmdlist (CuTest *tc) {
     1273
     1274#if defined (SH_WITH_SERVER)
     1275  struct socket_cmd cmd;
     1276  char * p;
     1277
     1278  sl_strlcpy(cmd.clt, "one", sizeof(cmd.clt));
     1279  sl_strlcpy(cmd.cmd, "RELOAD", sizeof(cmd.cmd));
     1280
     1281  sh_socket_add2list (&cmd);
     1282  p = sh_socket_check("one");
     1283  CuAssertPtrNotNull(tc, p);
     1284  CuAssertStrEquals(tc, "RELOAD", p);
     1285
     1286  p = sh_socket_check("one");
     1287  CuAssertPtrEquals(tc, NULL, p);
     1288
     1289  sh_socket_add2list (&cmd);
     1290  sl_strlcpy(cmd.cmd, "STOP",   sizeof(cmd.cmd));
     1291  sh_socket_add2list (&cmd);
     1292
     1293  sl_strlcpy(cmd.clt, "two", sizeof(cmd.clt));
     1294  sl_strlcpy(cmd.cmd, "STOP", sizeof(cmd.cmd));
     1295  sh_socket_add2list (&cmd);
     1296  sl_strlcpy(cmd.clt, "three", sizeof(cmd.clt));
     1297  sl_strlcpy(cmd.cmd, "STOP", sizeof(cmd.cmd));
     1298  sh_socket_add2list (&cmd);
     1299
     1300  sl_strlcpy(cmd.clt, "one", sizeof(cmd.clt));
     1301  sl_strlcpy(cmd.cmd, "DELTA",   sizeof(cmd.cmd));
     1302  sh_socket_add2list (&cmd);
     1303
     1304  p = sh_socket_check("one");
     1305  CuAssertPtrNotNull(tc, p);
     1306  CuAssertStrEquals(tc, "RELOAD", p);
     1307
     1308  sl_strlcpy(cmd.clt, "two", sizeof(cmd.clt));
     1309  sl_strlcpy(cmd.cmd, "RELOAD", sizeof(cmd.cmd));
     1310  sh_socket_add2list (&cmd);
     1311  sl_strlcpy(cmd.clt, "three", sizeof(cmd.clt));
     1312  sl_strlcpy(cmd.cmd, "RELOAD", sizeof(cmd.cmd));
     1313  sh_socket_add2list (&cmd);
     1314
     1315  p = sh_socket_check("one");
     1316  CuAssertPtrNotNull(tc, p);
     1317  CuAssertStrEquals(tc, "STOP", p);
     1318  p = sh_socket_check("one");
     1319  CuAssertPtrNotNull(tc, p);
     1320  CuAssertStrEquals(tc, "DELTA", p);
     1321  p = sh_socket_check("one");
     1322  CuAssertPtrEquals(tc, NULL, p);
     1323
     1324  /* Test removal in correct order */
     1325  sl_strlcpy(cmd.clt, "one", sizeof(cmd.clt));
     1326  sl_strlcpy(cmd.cmd, "RELOAD", sizeof(cmd.cmd));
     1327  sh_socket_add2list (&cmd);
     1328  sl_strlcpy(cmd.cmd, "STOP",   sizeof(cmd.cmd));
     1329  sh_socket_add2list (&cmd);
     1330  sl_strlcpy(cmd.cmd, "DELTA",  sizeof(cmd.cmd));
     1331  sh_socket_add2list (&cmd);
     1332  sl_strlcpy(cmd.cmd, "FOOBAR", sizeof(cmd.cmd));
     1333  sh_socket_add2list (&cmd);
     1334 
     1335  sh_socket_rm2list ("one", S_FALSE);
     1336
     1337  p = sh_socket_check("one");
     1338  CuAssertPtrNotNull(tc, p);
     1339  CuAssertStrEquals(tc, "STOP", p);
     1340
     1341  sh_socket_rm2list ("one", S_FALSE);
     1342 
     1343  p = sh_socket_check("one");
     1344  CuAssertPtrNotNull(tc, p);
     1345  CuAssertStrEquals(tc, "FOOBAR", p);
     1346
     1347  p = sh_socket_check("one");
     1348  CuAssertPtrEquals(tc, NULL, p);
     1349
     1350  sl_strlcpy(cmd.clt, "one", sizeof(cmd.clt));
     1351  sl_strlcpy(cmd.cmd, "RELOAD", sizeof(cmd.cmd));
     1352  sh_socket_add2list (&cmd);
     1353  sl_strlcpy(cmd.cmd, "STOP",   sizeof(cmd.cmd));
     1354  sh_socket_add2list (&cmd);
     1355
     1356  sl_strlcpy(cmd.clt, "two", sizeof(cmd.clt));
     1357  sl_strlcpy(cmd.cmd, "RELOAD", sizeof(cmd.cmd));
     1358  sh_socket_add2list (&cmd);
     1359  sl_strlcpy(cmd.clt, "three", sizeof(cmd.clt));
     1360  sl_strlcpy(cmd.cmd, "RELOAD", sizeof(cmd.cmd));
     1361  sh_socket_add2list (&cmd);
     1362
     1363  sl_strlcpy(cmd.clt, "one", sizeof(cmd.clt));
     1364  sl_strlcpy(cmd.cmd, "DELTA",  sizeof(cmd.cmd));
     1365  sh_socket_add2list (&cmd);
     1366  sl_strlcpy(cmd.cmd, "FOOBAR", sizeof(cmd.cmd));
     1367  sh_socket_add2list (&cmd);
     1368
     1369  sh_socket_rm2list ("one", S_TRUE);
     1370  p = sh_socket_check("one");
     1371  CuAssertPtrEquals(tc, NULL, p);
     1372
     1373  p = sh_socket_check("two");
     1374  CuAssertPtrNotNull(tc, p);
     1375  CuAssertStrEquals(tc, "STOP", p);
     1376  p = sh_socket_check("two");
     1377  CuAssertPtrNotNull(tc, p);
     1378  CuAssertStrEquals(tc, "RELOAD", p);
     1379  p = sh_socket_check("two");
     1380  CuAssertPtrEquals(tc, NULL, p);
     1381
     1382  p = sh_socket_check("three");
     1383  CuAssertPtrNotNull(tc, p);
     1384  CuAssertStrEquals(tc, "STOP", p);
     1385  p = sh_socket_check("three");
     1386  CuAssertPtrNotNull(tc, p);
     1387  CuAssertStrEquals(tc, "RELOAD", p);
     1388  p = sh_socket_check("three");
     1389  CuAssertPtrEquals(tc, NULL, p);
     1390
     1391  p = sh_socket_check("four");
     1392  CuAssertPtrEquals(tc, NULL, p);
     1393#else
     1394  (void) tc;
     1395#endif
     1396}
     1397
     1398#endif  /* #ifdef SH_CUTEST */
     1399
     1400
     1401

  • trunk/src/sh_static.c

    r473 r481  
    999999                return -1;
    10001000
    1001         while ((l = data[offset++])) {
     1001        while ((l = data[offset])) {
     1002
     1003                if (offset < INT_MAX)
     1004                        offset++;
     1005                else
     1006                        return -1;
    10021007
    10031008                if ((l & 0xc0) == (0xc0)) {
    1004                         offset++;
     1009                        if (offset < INT_MAX)
     1010                          offset++;
     1011                        else
     1012                          return -1;
    10051013                        break;
    10061014                }
    10071015
    1008                 offset += l;
     1016                if (offset <= (INT_MAX - l))
     1017                  offset += l;
     1018                else
     1019                  return -1;
    10091020        }
    10101021
    … …  
    10191030        if (i < 0)
    10201031                return i;
    1021 
    1022         return i + 4;
     1032        if (i < (INT_MAX - 4))
     1033          return i + 4;
     1034        else
     1035          return -1;
    10231036}
    10241037
    … …  
    10361049        if (!data)
    10371050                return -1;
    1038 
    1039         while ((l=data[offset++])) {
    1040                 if (measure)
     1051        while ((l=data[offset])) {
     1052                if (offset < INT_MAX) offset++;
     1053                else return -1;
     1054                if (measure && (total < INT_MAX))
    10411055                    total++;
    10421056                if ((l & 0xc0) == (0xc0)) {
    1043                         if (measure)
     1057                        if (measure && (total < INT_MAX))
    10441058                                total++;
    1045                         /* compressed item, redirect */
     1059                        /* compressed item, redirect */
    10461060                        offset = ((l & 0x3f) << 8) | data[offset];
     1061                        if (offset < 0)
     1062                          return -1;
    10471063                        measure = 0;
    10481064                        continue;
    10491065                }
     1066               
     1067                if (used >= (INT_MAX - l))
     1068                  return -1;
    10501069
    10511070                if ((used + l + 1) >= maxlen)
    1052                         return -1;
     1071                  return -1;
    10531072
    10541073                memcpy(dest + used, data + offset, l);
    1055                 offset += l;
    1056                 used += l;
    1057                 if (measure)
     1074               
     1075                if (offset <= (INT_MAX - l))
     1076                  offset += l;
     1077                else
     1078                  return -1;
     1079
     1080                if (used <= (INT_MAX - l))
     1081                  used += l;
     1082                else
     1083                  return -1;
     1084                if (measure && (total <= (INT_MAX - l)))
    10581085                        total += l;
    10591086
     1087                if (used == INT_MAX)
     1088                  return -1;
    10601089                if (data[offset] != 0)
    10611090                        dest[used++] = '.';
    … …  
    10651094
    10661095        /* The null byte must be counted too */
    1067         if (measure) {
     1096        if (measure && (total < INT_MAX)) {
    10681097            total++;
    10691098        }
    … …  
    10781107{
    10791108        char temp[256];
    1080         int i;
     1109        int i = 0;
    10811110
    10821111        i = __decode_dotted(message, offset, temp, sizeof(temp));
    … …  
    10841113                return i;
    10851114
    1086         message += offset + i;
     1115        if (offset <= (INT_MAX - i))
     1116          message += offset + i;
     1117        else
     1118          return -1;
    10871119
    10881120        a->dotted = strdup(temp);
    … …  
    11011133        DPRINTF("i=%d,rdlength=%d\n", i, a->rdlength);
    11021134
    1103         return i + RRFIXEDSZ + a->rdlength;
     1135        if (RRFIXEDSZ <= (INT_MAX - i))
     1136          i += RRFIXEDSZ;
     1137        else
     1138          return -1;
     1139        if (a->rdlength <= (INT_MAX - i))
     1140          return i + a->rdlength;
     1141        else
     1142          return -1;
    11041143}
    11051144
    … …  
    11481187
    11491188        dest += i;
     1189        if (maxlen < i)
     1190          return -1;
    11501191        maxlen -= i;
    11511192
    … …  
    11581199        dest[3] = (q->qclass & 0x00ff) >> 0;
    11591200
    1160         return i + 4;
     1201        if (i <= (INT_MAX - 4))
     1202          return i + 4;
     1203        else
     1204          return -1;
    11611205}
    11621206

  • trunk/src/sh_string.c

    r383 r481  
    1313
    1414extern int sl_ok_adds (size_t a, size_t b);
    15 #define SL_TRUE  1
    16 #define SL_FALSE 0
     15#define S_TRUE  1
     16#define S_FALSE 0
    1717
    1818#include <ctype.h>
    … …  
    389389sh_string * sh_string_cat_lchar(sh_string * s, const char * str, size_t len)
    390390{
    391   if (sl_ok_adds(len, s->siz) == SL_TRUE)
     391  if (sl_ok_adds(len, s->siz) == S_TRUE)
    392392    {
    393393      if ((len + 1 + s->len) > s->siz)
    … …  
    453453  size_t len = 0;
    454454
    455   if (sl_ok_adds(len1, len2) == SL_TRUE)
     455  if (sl_ok_adds(len1, len2) == S_TRUE)
    456456    len    = len1 + len2;
    457457  else
    458458    return NULL;
    459   if (sl_ok_adds( len, len3) == SL_TRUE)
     459  if (sl_ok_adds( len, len3) == S_TRUE)
    460460    len    = len  + len3;
    461461  else
    … …  
    482482    increase = SH_STRING_PARCEL;
    483483 
    484   if (s && sl_ok_adds(s->siz, increase) == SL_TRUE)
     484  if (s && sl_ok_adds(s->siz, increase) == S_TRUE)
    485485    {
    486486      new = SH_ALLOC(s->siz + increase);

  • trunk/src/sh_sub.c

    r429 r481  
    8383      close (child2parent[0]);
    8484
    85       /* fprintf(stderr, "FIXME kill_sub %d\n", (int) sh_child_pid); */
    86 
    8785      /* Let's be rude. */
    8886      kill(sh_child_pid, SIGKILL);
    … …  
    210208
    211209          sh_child_pid = res;
    212 
    213           /* fprintf(stderr, "FIXME create_sub %d\n", (int) sh_child_pid); */
    214210        }
    215211      else
    … …  
    252248static ssize_t sh_sub_write(int fd, const void *buf, size_t count)
    253249{
    254   char * mbuf = (char *) buf;
     250  const char * mbuf = (const char *) buf;
    255251  ssize_t rcount;
    256252  int ttl = 5; /* 0, 1, 9, 81, 729 millisec */
    … …  
    296292  do {
    297293
    298     /* fprintf(stderr, "FIXME wait_com polling..\n"); */
    299 
    300294    do {
    301295      ret = poll(&fds, 1, -1);
    … …  
    305299      {
    306300        ret = sh_sub_read(parent2child[0], &inbuf, sizeof(inbuf));
    307 
    308         /*
    309         fprintf(stderr, "FIXME wait_com stat %s (%s)\n",
    310                 inbuf.path, (inbuf.command == SH_COM_LSTAT) ? "lstat" : "stat");
    311         */
    312301
    313302        if (ret == 0)
    … …  
    328317            outbuf.errnum = errno;
    329318
    330             /* fprintf(stderr, "FIXME wait_com writing..\n"); */
    331 
    332319            ret = sh_sub_write(child2parent[1], &outbuf, sizeof(outbuf));
    333320            if (ret < 0)
    334321              {
    335                 /* fprintf(stderr, "FIXME wait_com return 1\n"); */
    336322                return;
    337323              }
    … …  
    339325        else /* sh_sub_read() < 0 */
    340326          {
    341             /* fprintf(stderr, "FIXME wait_com return 2\n"); */
    342327            return;
    343328          }
    344329      }
    345    
    346     /* fprintf(stderr, "FIXME wait_com next..\n"); */
    347 
    348330  } while (1 == 1);
    349331}

  • trunk/src/sh_suidchk.c

    r474 r481  
    7878#include "sh_suidchk.h"
    7979#include "sh_hash.h"
     80#include "sh_dbIO.h"
    8081#include "sh_unix.h"
    8182#include "sh_files.h"
    … …  
    140141static int     ShSuidchkActive   = S_TRUE;
    141142static time_t  ShSuidchkInterval = 7200;
    142 static long    ShSuidchkFps      = 0;
     143static unsigned long    ShSuidchkFps      = 0;
    143144static int     ShSuidchkNosuid   = S_FALSE;
    144145static int     ShSuidchkYield    = S_FALSE;
    … …  
    150151static time_t  FileLimNow        = 0;
    151152static time_t  FileLimStart      = 0;
    152 static long    FileLimNum        = 0;
    153 static long    FileLimTotal      = 0;
     153static unsigned long    FileLimNum        = 0;
     154static unsigned long    FileLimTotal      = 0;
    154155
    155156static sh_schedule_t * ShSuidchkSched = NULL;
    … …  
    11341135    /* Rate limit (Fps == Files per second)
    11351136     */
    1136     if ((ShSuidchkFps > 0 && FileLimNum > ShSuidchkFps && FileLimTotal > 0)&&
     1137    if ((ShSuidchkFps > 0 && FileLimNum > ShSuidchkFps) &&
    11371138        (ShSuidchkYield == S_FALSE))
    11381139      {
    … …  
    12221223            int dummy;
    12231224            int class;
    1224             unsigned long check_mask = 0;
     1225            unsigned long check_flags = 0;
    12251226
    12261227            theFile = SH_ALLOC(sizeof(file_type));
    12271228
    12281229            (void) sl_strlcpy (theFile->fullpath, tmpcat, PATH_MAX);
    1229             theFile->check_mask  = sh_files_maskof(SH_LEVEL_READONLY);
     1230            theFile->check_flags  = sh_files_maskof(SH_LEVEL_READONLY);
    12301231            CLEAR_SH_FFLAG_REPORTED(theFile->file_reported);
    12311232            theFile->attr_string = NULL;
    12321233            theFile->link_path   = NULL;
    12331234           
    1234             sh_files_search_file(tmpcat, &class,  &check_mask, &dummy);
    1235             if ((check_mask & MODI_PREL) != 0)
    1236               {
    1237                 theFile->check_mask |= MODI_PREL;
    1238               }
     1235            sh_files_search_file(tmpcat, &class,  &check_flags, &dummy);
     1236            if ((check_flags & MODI_PREL) != 0)
     1237              MODI_SET(theFile->check_flags, MODI_PREL);
    12391238
    12401239            status = sh_unix_getinfo (ShDFLevel[SH_ERR_T_RO],
    … …  
    13031302                    /* Running init. Report on files detected.
    13041303                     */
    1305                     sh_hash_pushdata (theFile, fileHash); /* no call to sh_error_handle */
     1304                    sh_dbIO_data_write (theFile, fileHash); /* no call to sh_error_handle */
    13061305                    SH_MUTEX_LOCK(mutex_thread_nolog);
    13071306                    sh_error_handle ((-1), FIL__, __LINE__,
    … …  
    22152214}
    22162215
    2217 /* This variable is not used anywhere. It only exists
    2218  * to assign &dirlist to it, which keeps gcc from
    2219  * putting it into a register, and avoids the 'clobbered
    2220  * by longjmp' warning. And no, 'volatile' proved insufficient.
    2221  */
    2222 static void * sh_dummy_type = NULL;
    2223 
    2224 
    22252216/* Return a newly allocated string naming the type of filesystem that the
    22262217   file PATH, described by STATP, is on.
    22272218   RELPATH is the file name relative to the current directory.
    22282219   Return "unknown" if its filesystem type is unknown.  */
     2220
     2221void * sh_dummy_2229_type;
    22292222
    22302223static char *
    … …  
    22432236  FILE *mfp;
    22442237  struct mntent *mnt;
     2238
     2239  /* Take the address to keep gcc from putting it into a register.
     2240   * Avoids the 'clobbered by longjmp' warning.
     2241   */
     2242  sh_dummy_2229_type = (void *) &type;
    22452243
    22462244  if (path == NULL || relpath == NULL)
    … …  
    22572255      return NULL;
    22582256    }
    2259 
    2260   /* Take the address to keep gcc from putting it into a register.
    2261    * Avoids the 'clobbered by longjmp' warning.
    2262    */
    2263   sh_dummy_type = (void*) &type;
    22642257
    22652258  /* Find the entry with the same device number as STATP, and return

  • trunk/src/sh_tiger0.c

    r444 r481  
    5555#endif
    5656
     57#if defined(__GNUC__) && (__GNUC__ >= 3)
     58#undef  SH_GNUC_ALIGN8
     59#define SH_GNUC_ALIGN8   __attribute__((aligned(8)))
     60#else
     61#undef  SH_GNUC_ALIGN8
     62#define SH_GNUC_ALIGN8
     63#endif
     64
     65
    5766typedef unsigned char sh_byte;
    5867
    … …  
    121130  char    * tmp;
    122131  sh_byte * bptr;
    123   sh_byte   bbuf[64];
     132  sh_byte   SH_GNUC_ALIGN8 bbuf[64];
    124133  UINT64    bcount = 0;
    125134
    … …  
    186195
    187196#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
    188     if (skey->mlock_failed == SL_FALSE)
     197    if (skey->mlock_failed == S_FALSE)
    189198      {
    190199        if ( (-1) == sh_unix_mlock(FIL__, __LINE__,
    … …  
    193202          {
    194203            SH_MUTEX_LOCK_UNSAFE(mutex_skey); 
    195             skey->mlock_failed = SL_TRUE;
     204            skey->mlock_failed = S_TRUE;
    196205            SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
    197206          }
    198207      }
    199208#else
    200     if (skey->mlock_failed == SL_FALSE)
     209    if (skey->mlock_failed == S_FALSE)
    201210      {
    202211        SH_MUTEX_LOCK_UNSAFE(mutex_skey); 
    203         skey->mlock_failed = SL_TRUE;
     212        skey->mlock_failed = S_TRUE;
    204213        SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
    205214      }
    … …  
    215224      {
    216225        if (timeout > 0)
    217           count = sl_read_timeout (fd, buffer, PRIV_MAX, timeout, SL_TRUE);
     226          count = sl_read_timeout (fd, buffer, PRIV_MAX, timeout, S_TRUE);
    218227        else
    219228          count = sl_read         (fd, buffer, PRIV_MAX);
    … …  
    903912
    904913      n = (off_t) sl_read_timeout (fd, buffer + sum,
    905                                    (size_t) BLOCKSIZE - sum, timeout, SL_FALSE);
     914                                   (size_t) BLOCKSIZE - sum, timeout, S_FALSE);
    906915
    907916      if (SL_ISERROR (n))
    … …  
    14501459    do {
    14511460      n = (off_t) sl_read_timeout(fd, buffer + sum,
    1452                                   (size_t) BLOCKSIZE - sum, timeout, SL_FALSE);
     1461                                  (size_t) BLOCKSIZE - sum, timeout, S_FALSE);
    14531462
    14541463      if (SL_ISERROR (n))
    … …  
    16091618}
    16101619
     1620void sh_tiger_get_mask_hashtype(unsigned long * mask)
     1621{
     1622  if (hash_type == SH_TIGER192)
     1623    *mask |= MODI_TIGER192;
     1624  else if (hash_type == SH_SHA1)
     1625    *mask |= MODI_SHA1;
     1626  else if (hash_type == SH_MD5)
     1627    *mask |= MODI_MD5;
     1628  else if (hash_type == SH_SHA256)
     1629    *mask |= MODI_SHA256;
     1630  return;
     1631}
     1632
     1633void sh_tiger_set_hashtype_mask(unsigned long mask)
     1634{
     1635  unsigned long type = mask & MODI_HASHTYPE;
     1636
     1637  if (type == MODI_TIGER192)
     1638    hash_type = SH_TIGER192;
     1639  else if (type == MODI_SHA1)
     1640    hash_type = SH_SHA1;
     1641  else if (type == MODI_MD5)
     1642    hash_type = SH_MD5;
     1643  else if (type == MODI_SHA256)
     1644    hash_type = SH_SHA256;
     1645  return;
     1646}
     1647
     1648
    16111649int sh_tiger_hashtype (const char * c)
    16121650{

  • trunk/src/sh_tiger1_64.c

    r474 r481  
    384384void tiger_compress(const word64 *str, word64 state[3])
    385385{
    386   tiger_compress_macro(((word64*)str), ((word64*)state));
     386  tiger_compress_macro(((const word64*)str), ((word64*)state));
    387387}
    388388
    … …  
    419419  register word64 i;
    420420  register word64 j = 0;
    421   unsigned char temp[64];
     421  union {
     422    word64 w64_temp[8];
     423    unsigned char temp[64];
     424  } dd;
    422425  union {
    423426    word64 itmp;
    … …  
    435438#ifdef BIG_ENDIAN
    436439      for(j=0; j<64; j++)
    437         temp[j^7] = ((sh_byte*)str)[j];
    438       tiger_compress(((word64*)temp), res);
     440        dd.temp[j^7] = ((sh_byte*)str)[j];
     441      tiger_compress((dd.w64_temp), res);
    439442#else
    440443      tiger_compress(str, res);
    … …  
    445448#ifdef BIG_ENDIAN
    446449  for(j=0; j<i; j++)
    447     temp[j^7] = ((sh_byte*)str)[j];
    448 
    449   temp[j^7] = 0x01;
     450    dd.temp[j^7] = ((sh_byte*)str)[j];
     451
     452  dd.temp[j^7] = 0x01;
    450453  j++;
    451454  for(; j&7; j++)
    452     temp[j^7] = 0;
     455    dd.temp[j^7] = 0;
    453456#else
    454457
    455458#ifndef USE_MEMSET
    456459  for(j=0; j<i; j++)
    457     temp[j] = ((sh_byte*)str)[j];
    458 #else
    459   memcpy( temp, str, j=i );
    460 #endif
    461   temp[j++] = 0x01;
     460    dd.temp[j] = ((const sh_byte*)str)[j];
     461#else
     462  memcpy( dd.temp, str, j=i );
     463#endif
     464  dd.temp[j++] = 0x01;
    462465  for(; j&7; j++)
    463         temp[j] = 0;
     466        dd.temp[j] = 0;
    464467
    465468#endif
    … …  
    469472#ifndef USE_MEMSET
    470473      for(; j<64; j++)
    471         temp[j] = 0;
    472 #else
    473       memset( temp+j, 0, 64-j);
    474 #endif
    475       tiger_compress(((word64*)temp), res);
     474        dd.temp[j] = 0;
     475#else
     476      memset( (dd.temp)+j, 0, 64-j);
     477#endif
     478      tiger_compress((dd.w64_temp), res);
    476479      j=0;
    477480    }
    … …  
    479482#ifndef USE_MEMSET
    480483  for(; j<56; j++)
    481     temp[j] = 0;
    482 #else
    483   memset( temp+j, 0, 56-j);
     484    dd.temp[j] = 0;
     485#else
     486  memset( (dd.temp)+j, 0, 56-j);
    484487#endif
    485488
    … …  
    488491  uu.itmp = ((word64)length)<<3;
    489492  for (j=0; j<8; j++)
    490         temp[56+j] = uu.ctmp[j];
    491 
    492   tiger_compress(((word64*)temp), res);
     493        dd.temp[56+j] = uu.ctmp[j];
     494
     495  tiger_compress((dd.w64_temp), res);
    493496}
    494497

  • trunk/src/sh_tools.c

    r472 r481  
    109109    p = (_("Key passed is not valid"));
    110110  else if (err_num == BAD_CIPHER_MODE)
    111     p = (_("Params struct passed to cipherInit invalid"));
     111    p = (_("Params struct passed to rijndael_cipherInit invalid"));
    112112  else if (err_num == BAD_CIPHER_STATE)
    113113    p = (_("Cipher in wrong state"));
    … …  
    13711371#if defined (SH_WITH_CLIENT) || defined (SH_WITH_SERVER)
    13721372
     1373#if defined (SH_WITH_CLIENT)
     1374
     1375static int           probe_done = S_FALSE;
     1376static unsigned char probe_flag = '\0';
     1377
     1378void sh_tools_probe_reset()
     1379{
     1380  probe_done = S_FALSE;
     1381  probe_flag = '\0';
     1382  return;
     1383}
     1384
     1385static int probe_ok(int flag)
     1386{
     1387  (void) flag;
     1388  if ((probe_flag & SH_PROTO_IVA) != 0)
     1389    return S_TRUE;
     1390  return S_FALSE;
     1391}
     1392
     1393static unsigned char probe_header_set(unsigned char protocol)
     1394{
     1395  if (probe_done || (protocol & SH_PROTO_SRP) == 0)
     1396    return 0;
     1397
     1398  return (char) SH_PROTO_IVA;
     1399}
     1400
     1401static void probe_header_get(unsigned char protocol)
     1402{
     1403  if (probe_done || (protocol & SH_PROTO_SRP) == 0)
     1404    return;
     1405
     1406  /* If the server doesn't know about it,
     1407   * it will simply mirror it back. */
     1408 
     1409  if ((protocol & SH_PROTO_IVA) != 0)
     1410    {
     1411      /* probe was mirrored */;
     1412    }
     1413  else
     1414    {
     1415      /* probe was UNset */
     1416      probe_flag |= SH_PROTO_IVA;
     1417    }
     1418  probe_done = S_TRUE;
     1419  return;
     1420}
     1421
     1422#else
     1423static unsigned char probe_header_set(unsigned char protocol) {
     1424  (void) protocol; return 0; }
     1425static void probe_header_get(unsigned char protocol) {
     1426  (void) protocol; return; }
     1427void sh_tools_probe_reset() { return; }
     1428
     1429unsigned char sh_tools_probe_store(unsigned char protocol, int * probe_flag)
     1430{
     1431  if ((protocol & SH_PROTO_SRP) == 0)
     1432    return protocol;
     1433
     1434  if ((protocol & SH_PROTO_IVA) != 0)
     1435    {
     1436      /* probe received */
     1437      *probe_flag |=  SH_PROTO_IVA;
     1438      protocol    &= ~SH_PROTO_IVA;
     1439    }
     1440  return protocol;
     1441}
     1442
     1443static int probe_ok(int flag)
     1444{
     1445  if ((flag & SH_PROTO_IVA) != 0)
     1446    return S_TRUE;
     1447  return S_FALSE;
     1448}
     1449#endif
     1450
     1451
    13731452void get_header (unsigned char * head, unsigned long * bytes, char * u)
    13741453{
    13751454  SL_ENTER(_("get_header"));
     1455
     1456  probe_header_get(head[0]);
    13761457
    13771458  *bytes =
    … …  
    13931474#if defined(SH_WITH_CLIENT) || defined(SH_WITH_SERVER)
    13941475
    1395 #ifdef  SH_ENCRYPT_2
     1476#ifdef  SH_ENCRYPT
    13961477#define TRANS_BYTES 65120
    13971478#else
    … …  
    13991480#endif
    14001481
    1401 void put_header (unsigned char * head, int protocol,
     1482void put_header (unsigned char * head, const int protocol,
    14021483                 unsigned long * length, char * u)
    14031484{
     1485  unsigned char probe = probe_header_set(protocol);
    14041486
    14051487  /* static long transfer_limit = (8 * SH_BUFSIZE); V0.8 */
    … …  
    14081490  SL_ENTER(_("put_header"));
    14091491
    1410   head[0]   = protocol;
     1492  head[0]   = protocol|probe;
    14111493
    14121494  ASSERT((*length < transfer_limit), _("*length < transfer_limit"))
    … …  
    14341516  SL_RET0(_("put_header"));
    14351517}
    1436 #endif
    14371518
    14381519/* ------------------------------------------
    … …  
    14531534 * only SH_V2_FULLSIZE is used, and only once
    14541535 */
    1455 #if 0
    1456 #ifdef SH_WITH_SERVER
    1457 #define SH_V2_FULLSIZE  240
    1458 #define SH_V2_PAYLOAD   224
    1459 #define SH_V2_MESSAGE   176
    1460 #else
    1461 #define SH_V2_FULLSIZE 1024
    1462 #define SH_V2_PAYLOAD  1008
    1463 #define SH_V2_MESSAGE   960
    1464 #endif
    1465 #endif
     1536
    14661537#define SH_V2_FULLSIZE 1024
    14671538
    … …  
    15081579
    15091580#ifdef SH_ENCRYPT
     1581
    15101582/*
    15111583 * #define DEBUG_EN2
    … …  
    15141586 * last 4 bytes of outgoing header are set to dummy value
    15151587 */
    1516 char * sh_tools_makePack (unsigned char * header,
     1588char * sh_tools_makePack (unsigned char * header, int flag,
    15171589                          char * payload, unsigned long payload_size,
    15181590                          keyInstance * keyInstE)
    15191591{
    1520   UINT32 rpad[3];
     1592  BYTE            inBlock[B_SIZ];
     1593  BYTE            outBlock[B_SIZ];
     1594  char            ivBlock[B_SIZ];
     1595
     1596  UINT32          rpad[3];
    15211597  unsigned char   head[16];
    1522   double epad;
    1523   unsigned long    i_epad = 0;
    1524   unsigned long    i_blk = payload_size / 16;
    1525   unsigned long    i_blkmax = SH_V2_FULLSIZE / 16;
    1526   unsigned long    pads = 0;
    1527   size_t full_size;
    1528   char * full_ret;
    1529 
    1530   char                  * p;
    1531   RIJ_BYTE                    inBlock[B_SIZ];
    1532   RIJ_BYTE                    outBlock[B_SIZ];
    1533   int                     j;
    1534   cipherInstance          cipherInst;
    1535   int                     err_num;
    1536   int                     blkfac;
    1537   int                     oflow = 0;
     1598  double          epad;
     1599  unsigned long   i_epad = 0;
     1600  unsigned long   i_blk = payload_size / 16;
     1601  unsigned long   i_blkmax = SH_V2_FULLSIZE / 16;
     1602  unsigned long   pads = 0;
     1603  size_t          full_size;
     1604  char          * full_ret;
     1605
     1606  unsigned char * p;
     1607  int             j;
     1608  cipherInstance  cipherInst;
     1609  int             err_num;
     1610  int             blkfac;
     1611  int             oflow = 0;
     1612  char expbuf[SH_ERRBUF_SIZE];
    15381613
    15391614  /*
    … …  
    15411616  */
    15421617  if ((i_blk * 16) != payload_size) ++i_blk;
    1543 #ifdef DEBUG_EN2
    1544   fprintf(stderr, "SEND <%d> blocks <%d>\n", payload_size, i_blk);
    1545 #endif
     1618
    15461619  /* random_pad
    15471620   */
    … …  
    15531626  memcpy (&head[8],  &rpad[2],    4);
    15541627
    1555   /* protocol
    1556    */
    1557   /* memcpy (&head[8],  &header[3], 4); */
    1558 
    15591628  /* size (payload)
    15601629   */
    … …  
    15661635  if (i_blk < i_blkmax)
    15671636  {
    1568     pads = i_blkmax - i_blk;
    1569     /* memcpy((char *) &rpad[2], &head[12], 4); */
    1570     epad = taus_get_double (&rpad);
    1571 #ifdef DEBUG_EN2
    1572     fprintf(stderr, "PAD1 <%d> <%f>\n", pads, epad);
    1573 #endif
     1637    pads   = i_blkmax - i_blk;
     1638    epad   = taus_get_double (&rpad);
    15741639    i_epad = (unsigned long) (pads * epad);
    1575 #ifdef DEBUG_EN2
    1576     fprintf(stderr, "PAD2 <%d> <%d>\n", i_epad, (i_epad*16));
    1577 #endif
    15781640  }
    15791641
    … …  
    15961658
    15971659  full_ret = SH_ALLOC(full_size);
     1660
    15981661  memcpy(full_ret,                   head,    16);
    15991662  if (payload != NULL && !oflow)
    1600     {
    1601       memcpy(&full_ret[16],              payload, payload_size);
    1602     }
     1663    memcpy(&full_ret[16],              payload, payload_size);
     1664
    16031665  if ((i_blk*16) > payload_size && !oflow)
    16041666    {
    1605 #ifdef DEBUG_EN2
    1606       fprintf(stderr, "SEN2 <%d>\n", (i_blk*16) - payload_size);
    1607 #endif
    16081667      memset(&full_ret[16+payload_size], '\0', (i_blk*16) - payload_size);
    16091668      payload_size = i_blk * 16;
    16101669    }
    16111670  memset(&full_ret[16+payload_size], '\0', i_epad*16);
    1612 #ifdef DEBUG_EN2
    1613   fprintf(stderr, "SEN3 <%d> <%d>\n", full_size, i_epad*16);
    1614 #endif
    16151671
    16161672  /* rewrite header
    … …  
    16181674  header[1]   = (unsigned int)(full_size/256);
    16191675  header[2]   = (unsigned int)(full_size - (256 * header[1]));
    1620   /* don't erase protocol from header
    1621      memset(&header[3], '\0', 4);
    1622   */
    1623   p = full_ret; blkfac = full_size / 16;
    1624 
    1625   err_num = cipherInit (&cipherInst, MODE_CBC, NULL);
     1676
     1677  p      = (unsigned char *) full_ret;
     1678  blkfac = full_size / B_SIZ;
     1679
     1680  err_num = rijndael_cipherInit (&cipherInst, MODE_CBC, NULL);
    16261681 
    1627   if (err_num < 0)
    1628     {
    1629       char expbuf[SH_ERRBUF_SIZE];
    1630       sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    1631                       errorExplain(err_num, expbuf, sizeof(expbuf)),
    1632                       _("sh_tools_makePack: cipherInit"));
    1633     }
    1634   for (j = 0; j < blkfac; ++j)
    1635     {
     1682  if (err_num < 0) {
     1683    sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
     1684                    errorExplain(err_num, expbuf, sizeof(expbuf)),
     1685                    _("sh_tools_makePack: rijndael_cipherInit")); }
     1686
     1687  if (probe_ok(flag)) {
     1688    memcpy(inBlock, p, B_SIZ);
     1689    err_num = rijndael_blockEncrypt(&cipherInst, keyInstE,
     1690                                    inBlock, 128, outBlock);
     1691    if (err_num >= 0) {
     1692      memcpy(p, outBlock, B_SIZ); p += B_SIZ;
     1693      memcpy(ivBlock, outBlock, sizeof(ivBlock));
     1694      err_num = rijndael_cipherInit (&cipherInst, MODE_CBC, ivBlock);
     1695      if (err_num >= 0) {
     1696        err_num = rijndael_blockEncrypt(&cipherInst, keyInstE,
     1697                                        p, 128*(blkfac-1), p);
     1698      }
     1699    }
     1700  }
     1701
     1702  else {
     1703    for (j = 0; j < blkfac; ++j) {
    16361704      memcpy(inBlock, p, B_SIZ);
    1637       err_num = blockEncrypt(&cipherInst, keyInstE,
    1638                              inBlock, 128 * BNUM, outBlock);
    1639       if (err_num < 0)
    1640         {
    1641           char expbuf[SH_ERRBUF_SIZE];
    1642           sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    1643                           errorExplain(err_num, expbuf, sizeof(expbuf)),
    1644                           _("sh_tools_makePack: blockEncrypt"));
    1645         }
     1705      err_num = rijndael_blockEncrypt(&cipherInst, keyInstE,
     1706                                      inBlock, 128, outBlock);
     1707     
     1708      if (err_num < 0) {
     1709        sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
     1710                        errorExplain(err_num, expbuf, sizeof(expbuf)),
     1711                        _("sh_tools_makePack: rijndael_blockEncrypt"));
     1712        break; }
     1713     
    16461714      memcpy(p, outBlock, B_SIZ);
    16471715      p += B_SIZ;
    16481716    }
     1717  }
    16491718
    16501719  return full_ret;
    … …  
    16541723 * last 4 bytes of incoming header are dummy
    16551724 */
    1656 char * sh_tools_revertPack (unsigned char * header, char * message,
     1725char * sh_tools_revertPack (unsigned char * header, int flag, char * message,
    16571726                            keyInstance * keyInstD,
    16581727                            unsigned long message_size)
    16591728{
     1729  BYTE                    inBlock[B_SIZ];
     1730  BYTE                    outBlock[B_SIZ];
     1731  char                    ivBlock[B_SIZ];
    16601732  unsigned long   msg_size;
    16611733  char          * msg_ret;
    16621734
    1663   char                  * p;
    1664   RIJ_BYTE                    inBlock[B_SIZ];
    1665   RIJ_BYTE                    outBlock[B_SIZ];
     1735  unsigned char         * p;
    16661736  int                     j;
    16671737  cipherInstance          cipherInst;
    … …  
    16711741
    16721742  msg_size = (256 * (unsigned int)header[1] + (unsigned int)header[2]);
    1673 #ifdef DEBUG_EN2
    1674   fprintf(stderr, "RECV <%lu>\n", msg_size);
    1675 #endif
    1676   if (msg_size > message_size) {
     1743  if (msg_size > message_size)
    16771744    msg_size = message_size;
    1678 #ifdef DEBUG_EN2
    1679     fprintf(stderr, "RECV TRUNC1 <%lu>\n", msg_size);
    1680 #endif
    1681   }
    1682 
    1683   p = message; blkfac = msg_size / 16;
    1684 
    1685   err_num = cipherInit (&cipherInst, MODE_CBC, NULL);
     1745
     1746  p = (unsigned char *) message; blkfac = msg_size / 16;
     1747
     1748  err_num = rijndael_cipherInit (&cipherInst, MODE_CBC, NULL);
    16861749 
    16871750  if (err_num < 0)
    … …  
    16891752      sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    16901753                      errorExplain(err_num, expbuf, sizeof(expbuf)),
    1691                       _("sh_tools_revertPack: cipherInit"));
    1692     }
    1693   for (j = 0; j < blkfac; ++j)
    1694     {
     1754                      _("sh_tools_revertPack: rijndael_cipherInit"));
     1755    }
     1756
     1757  if (probe_ok(flag)) {
     1758    memcpy(inBlock, p, B_SIZ);
     1759    err_num = rijndael_blockDecrypt(&cipherInst, keyInstD,
     1760                                    inBlock, 128, outBlock);
     1761    if (err_num >= 0) {
     1762      memcpy(p, outBlock, B_SIZ); p += B_SIZ;
     1763      memcpy(ivBlock, inBlock, sizeof(ivBlock));
     1764      err_num = rijndael_cipherInit (&cipherInst, MODE_CBC, ivBlock);
     1765      if (err_num >= 0) {
     1766        err_num = rijndael_blockDecrypt(&cipherInst, keyInstD,
     1767                                        p, 128*(blkfac-1), p);
     1768      }
     1769    }
     1770  }
     1771
     1772  else {
     1773    for (j = 0; j < blkfac; ++j) {
    16951774      memcpy(inBlock, p, B_SIZ);
    1696       err_num = blockDecrypt(&cipherInst, keyInstD,
    1697                              inBlock, 128 * BNUM, outBlock);
    1698       if (err_num < 0)
    1699         {
    1700           sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
    1701                           errorExplain(err_num, expbuf, sizeof(expbuf)),
    1702                           _("sh_tools_revertPack: blockDecrypt"));
    1703         }
     1775      err_num = rijndael_blockDecrypt(&cipherInst, keyInstD,
     1776                                      inBlock, 128, outBlock);
     1777 
     1778      if (err_num < 0) {
     1779        sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
     1780                        errorExplain(err_num, expbuf, sizeof(expbuf)),
     1781                        _("sh_tools_revertPack: rijndael_blockDecrypt"));
     1782        break; }
     1783     
    17041784      memcpy(p, outBlock, B_SIZ);
    17051785      p += B_SIZ;
    17061786    }
    1707  
     1787  }
     1788
    17081789  /* rewrite size in header
    17091790   */
    … …  
    17171798      header[1]   = (unsigned int)(msg_size/256);
    17181799      header[2]   = (unsigned int)(msg_size - (256 * header[1]));
    1719 #ifdef DEBUG_EN2
    1720       fprintf(stderr, "RECV TRUNC2 <%lu>\n", msg_size);
    1721 #endif
    1722     }
    1723 #ifdef DEBUG_EN2
    1724   fprintf(stderr, "REC2 <%lu>\n", msg_size);
    1725 #endif
    1726   /* protocol
    1727    */
    1728   /* memcpy(&header[3], &message[8], 4); */
     1800    }
    17291801
    17301802  /* payload
    … …  
    17321804  msg_ret = SH_ALLOC(msg_size+1);
    17331805  if (msg_size > 0)
    1734     {
    1735       memcpy(msg_ret, &message[16], msg_size);
    1736     }
     1806    memcpy(msg_ret, &message[16], msg_size);
    17371807  msg_ret[msg_size] = '\0';
    1738 #ifdef DEBUG_EN2
    1739   fprintf(stderr, "REC3 <%lu>\n", msg_size);
    1740 #endif
     1808
    17411809  SH_FREE(message);
    1742 
    17431810  return msg_ret;
    17441811}
    1745 #endif
     1812#endif /* #ifdef SH_ENCRYPT */
    17461813
    17471814int sh_tools_hash_add(char * key, char * buf, int buflen)
    … …  
    17811848  SL_RETURN((1), _("sh_tools_hash_vfy"));
    17821849}
     1850
     1851#endif /* defined(SH_WITH_CLIENT) || defined(SH_WITH_SERVER) */
     1852
    17831853
    17841854/* ------------------------------------------ */
    … …  
    18681938#if defined (SH_WITH_SERVER)
    18691939
    1870 char * get_client_conf_file (char * peer, unsigned long * length)
     1940char * get_client_conf_file (const char * peer, unsigned long * length)
    18711941{
    18721942  char * ret;
    … …  
    18741944  struct stat buf;
    18751945  char * base;
    1876   size_t size;
    18771946
    18781947  SL_ENTER(_("get_client_conf_file"));
    18791948
    18801949  base = sh_util_strdup(DEFAULT_DATAROOT);
    1881 
    1882   size = sl_strlen(base);
    1883   if (sl_ok_adds(size, sl_strlen(peer)))
    1884       size += sl_strlen(peer);
    1885   if (sl_ok_adds(size, 6))
    1886     size += 6;
    1887 
    1888   ret = SH_ALLOC(size);
    1889   sl_strlcpy(ret, base, size);
    1890   sl_strlcat(ret, _("/rc."), size);
    1891   sl_strlcat(ret, peer, size);
    1892  
     1950  ret = sh_util_strconcat(base, _("/rc."), peer, NULL);
     1951  if (!ret)
     1952    { SH_FREE(base); *length = 0; SL_RETURN(NULL, _("get_client_conf_file")); }
     1953
    18931954  status = retry_stat (FIL__, __LINE__, ret, &buf);
    1894 
    18951955  if (status == 0)
    18961956    goto lab_end;
    … …  
    18991959                    (long) sh.effective.uid, ret);
    19001960
    1901   sl_strlcpy(ret, base, size);
    1902   sl_strlcat(ret, "/rc", size);
     1961  SH_FREE(ret); ret = sh_util_strconcat(base, _("/rc"), NULL);
     1962  if (!ret)
     1963    { SH_FREE(base); *length = 0; SL_RETURN(NULL, _("get_client_conf_file")); }
    19031964 
    19041965  status = retry_stat (FIL__, __LINE__, ret, &buf);
    1905 
    19061966  if (status == 0)
    19071967    goto lab_end;
    … …  
    19101970                    (long) sh.effective.uid, ret);
    19111971
    1912   SH_FREE(base);
    1913   SH_FREE(ret);
    1914   *length=0;
     1972  SH_FREE(base); SH_FREE(ret); *length=0;
    19151973  SL_RETURN(NULL, _("get_client_conf_file"));
    19161974
    … …  
    19201978      sh_error_handle(SH_ERR_ERR, FIL__, __LINE__, status, MSG_E_SUBGEN,
    19211979                    _("File too large"), _("get_client_conf_file"));
    1922       SH_FREE(base);
     1980      SH_FREE(base); SH_FREE(ret); *length = 0;
    19231981      SL_RETURN(NULL, _("get_client_conf_file"));
    19241982    }
    1925   *length = (unsigned long) buf.st_size;
    1926   SH_FREE(base);
     1983
     1984  SH_FREE(base); *length = (unsigned long) buf.st_size;
    19271985  SL_RETURN(ret, _("get_client_conf_file"));
    19281986}
    19291987
    1930 char * get_client_data_file (char * peer, unsigned long * length)
     1988char * get_client_data_file (const char * peer, unsigned long * length)
    19311989{
    19321990  char * ret;
    19331991  int    status;
    19341992  struct stat buf;
    1935 
    19361993  char * base;
    1937   size_t size;
    19381994
    19391995  SL_ENTER(_("get_client_data_file"));
    19401996
    19411997  base = sh_util_strdup(DEFAULT_DATAROOT);
    1942 
    1943   size = sl_strlen(base);
    1944   if (sl_ok_adds(size, sl_strlen(peer)))
    1945       size += sl_strlen(peer);
    1946   if (sl_ok_adds(size, 8))
    1947     size += 8;
    1948 
    1949   ret = SH_ALLOC(size);
    1950   sl_strlcpy(ret, base, size);
    1951   sl_strlcat(ret, _("/file."), size);
    1952   sl_strlcat(ret, peer, size);
    1953  
     1998  ret = sh_util_strconcat(base, _("/file."), peer, NULL);
     1999  if (!ret)
     2000    { SH_FREE(base); *length = 0; SL_RETURN(NULL, _("get_client_data_file")); }
     2001
    19542002  status = retry_stat (FIL__, __LINE__, ret, &buf);
    1955 
    19562003  if (status == 0)
    19572004    goto lab1_end;
    … …  
    19602007                    (long) sh.effective.uid, ret);
    19612008
    1962 
    1963   sl_strlcpy(ret, base, size);
    1964   sl_strlcat(ret, _("/file"), size);
    1965  
     2009  SH_FREE(ret);
     2010  ret = sh_util_strconcat(base, _("/file"), NULL);
     2011  if (!ret)
     2012    { SH_FREE(base); *length = 0; SL_RETURN(NULL, _("get_client_data_file")); }
     2013
    19662014  status = retry_stat (FIL__, __LINE__, ret, &buf);
    1967 
    19682015  if (status == 0)
    19692016    goto lab1_end;
    … …  
    19722019                    (long) sh.effective.uid, ret);
    19732020
    1974 
    1975   *length = 0;
    1976   SH_FREE(base);
    1977   SH_FREE(ret);
     2021  *length = 0; SH_FREE(base); SH_FREE(ret);
    19782022  SL_RETURN(NULL, _("get_client_data_file"));
    19792023
    … …  
    19832027      sh_error_handle(SH_ERR_ERR, FIL__, __LINE__, status, MSG_E_SUBGEN,
    19842028                    _("File too large"), _("get_client_data_file"));
    1985       SH_FREE(base);
     2029      SH_FREE(base); SH_FREE(ret); *length = 0;
    19862030      SL_RETURN(NULL, _("get_client_data_file"));
    19872031    }
     2032
     2033  *length = (unsigned long) buf.st_size; SH_FREE(base);
     2034  SL_RETURN(ret, _("get_client_data_file"));
     2035}
     2036
     2037char * get_client_uuid_file (const char * peer, unsigned long * length, const char * uuid)
     2038{
     2039  char * ret;
     2040  int    status;
     2041  struct stat buf;
     2042  char * base;
     2043
     2044  SL_ENTER(_("get_client_uuid_file"));
     2045
     2046  base = sh_util_strdup(DEFAULT_DATAROOT);
     2047  ret = sh_util_strconcat(base, _("/file."), peer, ".", uuid, NULL);
     2048  SH_FREE(base);
     2049  if (!ret)
     2050    { *length = 0; SL_RETURN(NULL, _("get_client_uuid_file")); }
     2051
     2052  status = retry_stat (FIL__, __LINE__, ret, &buf);
     2053  if (status != 0)
     2054    {
     2055      sh_error_handle(SH_ERR_ERR, FIL__, __LINE__, status, MSG_E_ACCESS,
     2056                      (long) sh.effective.uid, ret);
     2057      SH_FREE(ret); *length = 0;
     2058      SL_RETURN(NULL, _("get_client_uuid_file"));
     2059    }
     2060  else if (buf.st_size > 0x7fffffff)
     2061    {
     2062      sh_error_handle(SH_ERR_ERR, FIL__, __LINE__, status, MSG_E_SUBGEN,
     2063                    _("File too large"), _("get_client_uuid_file"));
     2064      SH_FREE(ret); *length = 0;
     2065      SL_RETURN(NULL, _("get_client_data_file"));
     2066    }
     2067
    19882068  *length = (unsigned long) buf.st_size;
    1989   SH_FREE(base);
    1990   SL_RETURN(ret, _("get_client_data_file"));
    1991  
    1992 }
     2069  SL_RETURN(ret, _("get_client_uuid_file"));
     2070}
     2071
    19932072#endif
    19942073
    … …  
    20912170  if (SL_ISERROR(fd))
    20922171    {
    2093       sh_error_handle(SH_ERR_ALL, FIL__, __LINE__, fd, MSG_E_SUBGEN,
     2172      sh_error_handle((-1), FIL__, __LINE__, fd, MSG_E_SUBGEN,
    20942173                      _("Error opening temporary file"), _("open_tmp"));
    20952174      TPT(( 0, FIL__, __LINE__, _("msg=<Error %d temporary file %s>\n"),
    20962175            fd, file));
    20972176    }
    2098  
    20992177
    21002178  SH_FREE (file);

  • trunk/src/sh_unix.c

    r474 r481  
    103103#include "sh_prelink.h"
    104104#include "sh_pthread.h"
     105#include "sh_sem.h"
    105106
    106107/* moved here from far below
    … …  
    482483  sl_strlcat(msg, details, 128);
    483484  (void) safe_logger (thesignal, method, msg);
     485
     486  close_ipc ();
    484487  raise(SIGKILL);
    485488}
    … …  
    526529          } while (val_return < 0 && errno == EINTR);
    527530
     531          close_ipc ();
    528532          safe_logger (mysignal, 0, NULL);
    529533        }
    … …  
    594598      if (skey != NULL)
    595599        memset (skey, '\0', sizeof(sh_key_t));
    596 #ifdef WITH_MESSAGE_QUEUE
    597600      close_ipc ();
    598 #endif
    599601      safe_logger (mysignal, 0, NULL);
    600602      do {
    … …  
    636638  if (skey != NULL)
    637639    memset (skey, '\0', sizeof(sh_key_t));
    638 #ifdef WITH_MESSAGE_QUEUE
    639640  close_ipc ();
    640 #endif
    641641
    642642  do {
    … …  
    669669#endif
    670670#ifdef SIGTTOU
    671   if (mysignal == SIGTTOU)
    672     sig_force_check = 1;
     671  if (mysignal == SIGTTOU) {
     672    sig_force_check = 1; sh_sem_trylock(); }
    673673#endif
    674674#ifdef SIGTTIN
    … …  
    682682#ifdef SIGQUIT
    683683  if (mysignal == SIGQUIT)
    684     {
    685       sig_terminate       = 1;
    686       ++sig_urgent;
    687     }
     684    sig_terminate       = 1;
    688685#endif
    689686#ifdef SIGTERM
    … …  
    10421039      if ((status == ERANGE) && (w == NULL))
    10431040        {
    1044           if (SL_TRUE ==  sl_ok_adds( gbufsize, SH_GRBUF_SIZE ))
     1041          if (S_TRUE ==  sl_ok_adds( gbufsize, SH_GRBUF_SIZE ))
    10451042            {
    10461043              SH_FREE(buffer);
    … …  
    17221719  struct utsname   buf;
    17231720  int              i;
    1724   int              ddot;
     1721  unsigned int     ddot;
    17251722  int              len;
    17261723  char           * p;
    … …  
    18921889   */
    18931890#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
    1894   if (skey->mlock_failed == SL_FALSE)
     1891  if (skey->mlock_failed == S_FALSE)
    18951892    {
    18961893      if ( (-1) == sh_unix_mlock( FIL__, __LINE__,
    … …  
    18981895        {
    18991896          SH_MUTEX_LOCK_UNSAFE(mutex_skey);
    1900           skey->mlock_failed = SL_TRUE;
     1897          skey->mlock_failed = S_TRUE;
    19011898          SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
    19021899        }
    19031900    }
    19041901#else
    1905   if (skey->mlock_failed == SL_FALSE)
     1902  if (skey->mlock_failed == S_FALSE)
    19061903    {
    19071904      SH_MUTEX_LOCK_UNSAFE(mutex_skey);
    1908       skey->mlock_failed = SL_TRUE;
     1905      skey->mlock_failed = S_TRUE;
    19091906      SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
    19101907    }
    … …  
    19801977
    19811978  if (dummy == NULL)
    1982     sh.flag.isdaemon = ON;
     1979    sh.flag.isdaemon = S_TRUE;
    19831980  else
    19841981    res = sh_util_flagval (dummy, &sh.flag.isdaemon);
    … …  
    20032000
    20042001  if (dummy == NULL)
    2005     sh.flag.isdaemon = OFF;
     2002    sh.flag.isdaemon = S_FALSE;
    20062003  else
    20072004    res = sh_util_flagval (dummy, &sh.flag.isdaemon);
    … …  
    22212218    char * tz = sh_util_strdup(getenv("TZ")); /* flawfinder: ignore */
    22222219    size_t tzlen = strlen(tz);
    2223     if (SL_TRUE == sl_ok_adds (4, tzlen)) {
     2220    if (S_TRUE == sl_ok_adds (4, tzlen)) {
    22242221        env[3] = SH_ALLOC(4+tzlen);
    22252222        sl_strlcpy(env[3], "TZ=", 4);
    … …  
    22442241      memset(skey, 0, sizeof(sh_key_t));
    22452242      (void) umask(S_IRGRP|S_IWGRP|S_IXGRP|S_IROTH|S_IWOTH|S_IXOTH);
    2246       sh_unix_closeall (3, -1, SL_TRUE); /* in child process */
     2243      sh_unix_closeall (3, -1, S_TRUE); /* in child process */
    22472244      execve(path, arg, env);
    22482245      _exit(EXIT_FAILURE);
    … …  
    22842281  struct tm   bb;
    22852282
     2283  struct tm * aptr;
     2284  struct tm * bptr;
     2285
    22862286  int  sign =  0;
    22872287  int  diff =  0;
    … …  
    22922292
    22932293#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GMTIME_R)
    2294   gmtime_r (xx, &aa);
     2294  aptr = gmtime_r (xx, &aa);
    22952295#else
    2296   memcpy (&aa, gmtime(xx), sizeof(struct tm));
     2296  aptr = gmtime(xx);
     2297  if (aptr)
     2298    memcpy (&aa, aptr, sizeof(struct tm));
    22972299#endif
    22982300
    22992301#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R)
    2300   localtime_r (xx, &bb);
     2302  bptr = localtime_r (xx, &bb);
    23012303#else
    2302   memcpy (&bb, localtime(xx), sizeof(struct tm));
    2303 #endif
    2304 
    2305   /* Check for datum wrap-around.
    2306    */
    2307   if      (aa.tm_year < bb.tm_year)
    2308     sign = (-1);
    2309   else if (aa.tm_mon  < bb.tm_mon)
    2310     sign = (-1);
    2311   else if (aa.tm_mday < bb.tm_mday)
    2312     sign = (-1);
    2313   else if (bb.tm_year < aa.tm_year)
    2314     sign = ( 1);
    2315   else if (bb.tm_mon  < aa.tm_mon)
    2316     sign = ( 1);
    2317   else if (bb.tm_mday < aa.tm_mday)
    2318     sign = ( 1);
    2319 
    2320   diff = aa.tm_hour * 60 + aa.tm_min;
    2321   diff = (bb.tm_hour * 60 + bb.tm_min) - diff;
    2322   diff = diff - (sign * 24 * 60);   /* datum wrap-around correction */
    2323   hh = diff / 60;
    2324   mm = diff - (hh * 60);
    2325   sprintf (tz, _("%+03d%02d"), hh, mm);                /* known to fit  */
    2326 
     2304  bptr = localtime(xx);
     2305  if (bptr)
     2306    memcpy (&bb, bptr, sizeof(struct tm));
     2307#endif
     2308
     2309  if (bptr && aptr)
     2310    {
     2311      /* Check for datum wrap-around.
     2312       */
     2313      if      (aa.tm_year < bb.tm_year)
     2314        sign = (-1);
     2315      else if (aa.tm_mon  < bb.tm_mon)
     2316        sign = (-1);
     2317      else if (aa.tm_mday < bb.tm_mday)
     2318        sign = (-1);
     2319      else if (bb.tm_year < aa.tm_year)
     2320        sign = ( 1);
     2321      else if (bb.tm_mon  < aa.tm_mon)
     2322        sign = ( 1);
     2323      else if (bb.tm_mday < aa.tm_mday)
     2324        sign = ( 1);
     2325     
     2326      diff = aa.tm_hour * 60 + aa.tm_min;
     2327      diff = (bb.tm_hour * 60 + bb.tm_min) - diff;
     2328      diff = diff - (sign * 24 * 60);   /* datum wrap-around correction */
     2329      hh = diff / 60;
     2330      mm = diff - (hh * 60);
     2331      sprintf (tz, _("%+03d%02d"), hh, mm);                /* known to fit  */
     2332    }
     2333  else
     2334    {
     2335      sprintf (tz, _("%+03d%02d"), 0, 0);
     2336    }
    23272337  SL_RETURN(tz, _("t_zone"));
    23282338}
    … …  
    25602570static int sh_unix_use_localtime = S_FALSE;
    25612571
    2562 /* whether to use localtime for file timesatams in logs
     2572/* whether to use localtime for file timestamps in logs
    25632573 */
    25642574int sh_unix_uselocaltime (const char * c)
    … …  
    34853495
    34863496int sh_unix_checksum_size (char * filename, off_t size, int is_max_size,
    3487                            char * fileHash, int alert_timeout, SL_TICKET fd)
     3497                           char * fileHash, int alert_timeout, SL_TICKET fd, unsigned long mask)
    34883498{
    34893499  file_type * tmpFile;
    … …  
    35173527      char hashbuf[KEYBUF_SIZE];
    35183528      UINT64 local_length = (UINT64) (tmpFile->size < 0 ? 0 : tmpFile->size);
     3529      if (sh.flag.opts == S_TRUE) sh_tiger_set_hashtype_mask(mask);
    35193530      sl_strlcpy(fileHash,
    35203531                 sh_tiger_generic_hash (filename, fd, &(local_length),
    … …  
    35413552
    35423553int sh_check_rotated_log (const char * path, 
    3543                           UINT64 old_size, UINT64 old_inode, const char * old_hash)
     3554                          UINT64 old_size, UINT64 old_inode, const char * old_hash, unsigned long mask)
    35443555{
    35453556  struct stat obuf;
    … …  
    35603571          if (!SL_ISERROR(fd))
    35613572            {
    3562               sh_unix_checksum_size (rotated_file, old_size, S_FALSE, hashbuf, 120 /* alert_timeout */, fd);
     3573              sh_unix_checksum_size (rotated_file, old_size, S_FALSE,
     3574                                     hashbuf, 120 /* alert_timeout */, fd, mask);
    35633575             
    35643576              sl_close(fd);
    … …  
    38143826  SL_ENTER(_("sh_unix_getinfo"));
    38153827
    3816   if (!MODI_INITIALIZED(theFile->check_mask))
     3828  if (!MODI_INITIALIZED(theFile->check_flags))
    38173829    {
    38183830      tmp2 = sh_util_safe_name (theFile->fullpath);
    … …  
    38233835      SH_MUTEX_UNLOCK(mutex_thread_nolog);
    38243836      SH_FREE(tmp2);
     3837      SL_RETURN((-1),_("sh_unix_getinfo"));
    38253838    }
    38263839
    … …  
    39894002      if (fileHash != NULL)
    39904003        {
    3991           if ((theFile->check_mask & MODI_CHK) == 0 ||
     4004          if ((theFile->check_flags & MODI_CHK) == 0 ||
    39924005              sh_restrict_this(theFile->fullpath, (UINT64) fbuf.st_size,
    39934006                               (UINT64) fbuf.st_mode, rval_open))
    … …  
    39954008              sl_strlcpy(fileHash, SH_KEY_NULL, KEY_LEN+1);
    39964009            }
    3997           else if ((theFile->check_mask & MODI_PREL) != 0 &&
     4010          else if ((theFile->check_flags & MODI_PREL) != 0 &&
    39984011                   S_TRUE == sh_prelink_iself(rval_open, fbuf.st_size,
    39994012                                              alert_timeout, theFile->fullpath))
    40004013            {
    40014014              if (0 != sh_prelink_run (theFile->fullpath,
    4002                                        fileHash, alert_timeout))
     4015                                       fileHash, alert_timeout, theFile->check_flags))
    40034016                sl_strlcpy(fileHash, SH_KEY_NULL, KEY_LEN+1);
    40044017            }
    … …  
    40084021              UINT64 length_current = TIGER_NOLIM;
    40094022
    4010               if (MODI_TXT_ENABLED(theFile->check_mask) && fbuf.st_size < (10 * SH_TXT_MAX))
     4023              if (MODI_TXT_ENABLED(theFile->check_flags) && fbuf.st_size < (10 * SH_TXT_MAX))
    40114024                {
    40124025                  sl_init_content (rval_open, fbuf.st_size);
    40134026                }
    40144027
     4028              if (sh.flag.opts == S_TRUE) sh_tiger_set_hashtype_mask(theFile->check_flags);
    40154029              sl_strlcpy(fileHash,
    40164030                         sh_tiger_generic_hash (theFile->fullpath,
    … …  
    40234037              content = sh_string_copy(content);
    40244038
    4025               if ((theFile->check_mask & MODI_SGROW) != 0)
     4039              if ((theFile->check_flags & MODI_SGROW) != 0)
    40264040                {
    40274041                  /* Update size so it matches the one for which the checksum
    … …  
    40324046                  sh_unix_checksum_size (theFile->fullpath, length_current, S_TRUE,
    40334047                                         &fileHash[KEY_LEN + 1],
    4034                                          alert_timeout, rval_open);
     4048                                         alert_timeout, rval_open, theFile->check_flags);
    40354049                }
    40364050            }
    … …  
    40464060      if (fileHash != NULL)
    40474061        {
    4048           if ((theFile->check_mask & MODI_CHK) == 0 ||
     4062          if ((theFile->check_flags & MODI_CHK) == 0 ||
    40494063              sh_restrict_this(theFile->fullpath, (UINT64) fbuf.st_size,
    40504064                               (UINT64) fbuf.st_mode, rval_open))
    … …  
    40574071            {
    40584072              if (0 != sh_prelink_run (theFile->fullpath,
    4059                                        fileHash, alert_timeout))
     4073                                       fileHash, alert_timeout, theFile->check_flags))
    40604074                sl_strlcpy(fileHash, SH_KEY_NULL, KEY_LEN+1);
    40614075            }
    … …  
    40654079              UINT64 length_current = TIGER_NOLIM;
    40664080
    4067               if (MODI_TXT_ENABLED(theFile->check_mask) && fbuf.st_size < (10 * SH_TXT_MAX))
     4081              if (MODI_TXT_ENABLED(theFile->check_flags) && fbuf.st_size < (10 * SH_TXT_MAX))
    40684082                {
    40694083                  sl_init_content (rval_open, fbuf.st_size);
    40704084                }
    40714085
     4086              if (sh.flag.opts == S_TRUE) sh_tiger_set_hashtype_mask(theFile->check_flags);
    40724087              sl_strlcpy(fileHash,
    40734088                         sh_tiger_generic_hash (theFile->fullpath, rval_open,
    … …  
    40804095              content = sh_string_copy(content);
    40814096
    4082               if ((theFile->check_mask & MODI_SGROW) != 0)
     4097              if ((theFile->check_flags & MODI_SGROW) != 0)
    40834098                {
    40844099                  /* Update size so it matches the one for which the checksum
    … …  
    40894104                  sh_unix_checksum_size (theFile->fullpath, length_current, S_TRUE,
    40904105                                         &fileHash[KEY_LEN + 1],
    4091                                          alert_timeout, rval_open);
     4106                                         alert_timeout, rval_open, theFile->check_flags);
    40924107                }
    40934108            }
    … …  
    41054120        sl_strlcpy(fileHash, SH_KEY_NULL, KEY_LEN+1);
    41064121
    4107       if ((theFile->check_mask & MODI_CHK) != 0)
     4122      if ((theFile->check_flags & MODI_CHK) != 0)
    41084123        {
    41094124          tmp2 = sh_util_safe_name (theFile->fullpath);
    … …  
    42764291  /* --- Output the file. ---
    42774292   */
    4278   if (flag_err_debug == SL_TRUE)
     4293  if (flag_err_debug == S_TRUE)
    42794294    {
    42804295      tmp2 = sh_util_safe_name ((filename == NULL) ?
    … …  
    52945309int sh_unix_count_mlock()
    52955310{
    5296   int i = 0;
     5311  unsigned int i = 0;
    52975312  char str[32][64];
    52985313  sh_page_l * page_list;
    … …  
    53255340#ifdef WITH_TPT
    53265341  {
    5327     int j = 0;
     5342    unsigned int j = 0;
    53285343    while (j < i && j < 32)
    53295344      {
    5330         sh_error_handle(SH_ERR_INFO, FIL__, __LINE__, j, MSG_E_SUBGEN,
     5345        sh_error_handle(SH_ERR_ALL, FIL__, __LINE__, j, MSG_E_SUBGEN,
    53315346                        str[j], _("sh_unix_count_mlock"));
    53325347        ++j;
    … …  
    53365351
    53375352  sl_snprintf(str[0], 64, _("%d pages locked"), i);
    5338   sh_error_handle(SH_ERR_INFO, FIL__, __LINE__, i, MSG_E_SUBGEN,
     5353  sh_error_handle(SH_ERR_ALL, FIL__, __LINE__, i, MSG_E_SUBGEN,
    53395354                  str[0], _("sh_unix_count_mlock"));
    53405355  SL_RETURN((i), _("sh_unix_count_mlock"));
    … …  
    55155530      this_line  = 0;
    55165531      c          = '\0';
    5517       while (c != '\n' && num > 0 && this_line < (sizeof(theline)-1))
     5532      while (c != '\n' && this_line < (sizeof(theline)-1))
    55185533        {
    55195534          do {

  • trunk/src/sh_utils.c

    r473 r481  
    309309          }
    310310        }
    311         out[rem] = ','; ++rem;
    312         while (p[1] == '\n') ++p; /* scan over consecutive newlines */
     311        out[rem] = ','; ++rem;    /* <-- ensures (rem > 0) is true    */
     312        while (p[1] == '\n') ++p; /* scan over consecutive newlines   */
    313313        state = 0;
    314314        if (p[1] == '\0') {
    315           if (rem > 0) out[rem-1] = '\0';
     315          out[rem-1] = '\0';      /* rem > 0 because of 4 lines above */
    316316          break;
    317317        }
    … …  
    782782  char hashbuf[KEYBUF_SIZE];
    783783
    784 
     784  int         result;
    785785  size_t      i;
    786786
    787787  SL_ENTER(_("sh_util_hmac_tiger"));
    788   ASSERT((KEY_BLOCK <= (KEY_LEN/2)), _("KEY_BLOCK <= (KEY_LEN/2)"))
    789 
    790   if (KEY_BLOCK > (KEY_LEN/2))
    791     {
    792       (void) sh_tiger_hash (NULL, TIGER_DATA, 0, hashbuf, sizeof(hashbuf));
    793       sl_strlcpy(res, hashbuf, len);
    794       SL_RETURN(res, _("sh_util_hmac_tiger"));
    795     }
     788
     789  ASSERT((KEY_BLOCK <= (KEY_LEN/2)), _("KEY_BLOCK <= (KEY_LEN/2)"));
    796790
    797791  memcpy (K, zap, KEY_BLOCK);
    798792
    799   if (sh_util_hextobinary (K, hexkey, KEY_LEN) < 0)
    800     {
    801       (void) sh_tiger_hash (NULL, TIGER_DATA, 0, hashbuf, sizeof(hashbuf));
    802       sl_strlcpy(res, hashbuf, len);
    803       SL_RETURN(res, _("sh_util_hmac_tiger"));
    804     }
    805 
    806   if (sl_ok_adds(textlen, KEY_BLOCK))
     793  result = sh_util_hextobinary (K, hexkey, KEY_LEN);
     794
     795  ASSERT((result >= 0), _("result >= 0"));
     796
     797  if ((result >= 0) && sl_ok_adds(textlen, KEY_BLOCK))
    807798    {
    808799      inner = (char *) SH_ALLOC (textlen + KEY_BLOCK);
    … …  
    830821  /* now compute the hash
    831822   */
    832   h1 = sh_tiger_hash_uint32 ( outer,
    833                               TIGER_DATA,
    834                               KEY_BLOCK,
     823  h1 = sh_tiger_hash_uint32 ( outer, TIGER_DATA, KEY_BLOCK,
    835824                              kbuf, KEY_BYT/sizeof(UINT32));
    836825  for (i = 0; i < (KEY_LEN/8); ++i)
    837     {
    838       /* cc[i] = h1[i]; */
    839       copy_four ( (unsigned char *) &(cc[i]), h1[i]);
    840     }
    841 
    842   h2 = sh_tiger_hash_uint32 ( inner,
    843                               TIGER_DATA,
     826    copy_four ( (unsigned char *) &(cc[i]), h1[i]);
     827
     828  h2 = sh_tiger_hash_uint32 ( inner, TIGER_DATA,
    844829                              (unsigned long) KEY_BLOCK+textlen,
    845830                              kbuf, KEY_BYT/sizeof(UINT32));
    846831  for (i = KEY_LEN/8; i < (KEY_LEN/4); ++i)
    847     {
    848       copy_four ( (unsigned char *) &(cc[i]), h2[i - (KEY_LEN/8)]);
    849       /* cc[i] = h2[i - (KEY_LEN/8)]; */
    850     }
     832    copy_four ( (unsigned char *) &(cc[i]), h2[i - (KEY_LEN/8)]);
     833
    851834  SH_FREE(inner);
    852835 
    … …  
    10331016
    10341017
    1035 /* interval [0, 4294967296]
     1018/* interval [0, 4294967295]
    10361019 */
    10371020static UINT32 taus_get_long (void *vstate)
    … …  
    11601143  char                 bufx[9 * sizeof(UINT32) + 1];
    11611144  int                  status;
    1162   static unsigned long seed_time = 0;
     1145  static unsigned long seed_time    = 0;
     1146  static unsigned long seed_counter = 3000;
    11631147  unsigned long        gtime;
    11641148
    … …  
    11671151  if (skey->rngI == GOOD)
    11681152    {
    1169       if ( (sh_unix_longtime () - seed_time) < 7200)
     1153      ++seed_counter;
     1154
     1155      if ( ((sh_unix_longtime () - seed_time) < 1800) &&
     1156           ( seed_counter                     < 3000))
    11701157        SL_RETURN( (0), _("taus_seed"));
    11711158    }
    11721159 
    1173   seed_time = sh_unix_longtime ();
     1160  seed_time    = sh_unix_longtime ();
     1161  seed_counter = 0;
    11741162
    11751163  status = sh_entropy (24, bufx);
    … …  
    18341822int sh_util_obscurename (ShErrLevel level, const char * name_orig, int flag)
    18351823{
    1836   const unsigned char * name = (unsigned char *) name_orig;
     1824  const unsigned char * name = (const unsigned char *) name_orig;
    18371825  char * safe;
    18381826  unsigned int i;
    … …  
    23082296  unsigned char b;
    23092297  size_t lout = 0;
    2310   int    w = 0;
     2298  unsigned int  w = 0;
    23112299
    23122300  if (out && in)

  • trunk/src/sh_utmp.c

    r474 r481  
    848848 * by longjmp' warning. And no, 'volatile' proved insufficient.
    849849 */
    850 static void * sh_dummy_userold = NULL;
    851 static void * sh_dummy_user    = NULL;
     850void * sh_dummy_850_userold = NULL;
     851void * sh_dummy_851_user    = NULL;
    852852
    853853
    … …  
    883883   * Avoids the 'clobbered by longjmp' warning.
    884884   */
    885   sh_dummy_userold = (void*) &userold;
    886   sh_dummy_user    = (void*) &user;
     885  sh_dummy_850_userold = (void*) &userold;
     886  sh_dummy_851_user    = (void*) &user;
    887887
    888888  /* ------- find user --------
    … …  
    11331133
    11341134 out:
    1135   sh_dummy_user    = NULL;
    1136   sh_dummy_userold = NULL;
     1135  sh_dummy_851_user    = NULL;
     1136  sh_dummy_850_userold = NULL;
    11371137
    11381138  SL_RET0(_("sh_utmp_addlogin"));

  • trunk/src/slib.c

    r476 r481  
    587587
    588588
     589#if !defined (VA_COPY)
     590#if defined (__GNUC__) && defined (__PPC__) && (defined (_CALL_SYSV) || defined (_WIN32))
     591#define VA_COPY(ap1, ap2)     (*(ap1) = *(ap2))
     592#elif defined (VA_COPY_AS_ARRAY)
     593#define VA_COPY(ap1, ap2)     memmove ((ap1), (ap2), sizeof (va_list))
     594#else /* va_list is a pointer */
     595#define VA_COPY(ap1, ap2)     ((ap1) = (ap2))
     596#endif
     597#endif
     598
    589599#if !defined(HAVE_VSNPRINTF) || defined(HAVE_BROKEN_VSNPRINTF)
    590600static
    … …  
    774784  str[n-1] = '\0';
    775785#else
    776   va_copy(vl2, vl);                      /* save the argument list           */
     786  VA_COPY (vl2, vl);                     /* save the argument list           */
    777787  total = sl_printf_count (format, vl);
    778788  len = (int) total;
    … …  
    820830  str[n-1] = '\0';
    821831#else
    822   va_copy(vl2, vl);                    /* save the argument list           */
     832  VA_COPY (vl2, vl);                   /* save the argument list           */
    823833  total = sl_printf_count (format, vl);
    824834  if (total < n)
    … …  
    11411151static   gid_t   rgid_orig;
    11421152
    1143 static   int     uids_are_stored = SL_FALSE;
    1144 static   int     suid_is_set     = SL_TRUE;
     1153static   int     uids_are_stored = S_FALSE;
     1154static   int     suid_is_set     = S_TRUE;
    11451155
    11461156#ifdef HAVE_SETRESUID
    … …  
    11561166int sl_is_suid()
    11571167{
    1158   if (uids_are_stored == SL_FALSE)
     1168  if (uids_are_stored == S_FALSE)
    11591169    {
    11601170      if (getuid() == geteuid() && getgid() == getegid())
    … …  
    11791189{
    11801190  SL_ENTER(_("sl_get_euid"));
    1181   /* SL_REQUIRE(uids_are_stored == SL_TRUE, _("uids_are_stored == SL_TRUE"));*/
    1182   if (uids_are_stored == SL_TRUE)
     1191  /* SL_REQUIRE(uids_are_stored == S_TRUE, _("uids_are_stored == S_TRUE"));*/
     1192  if (uids_are_stored == S_TRUE)
    11831193    *ret = euid;
    11841194  else
    … …  
    11891199uid_t sl_ret_euid()
    11901200{
    1191   /* SL_REQUIRE(uids_are_stored == SL_TRUE, _("uids_are_stored == SL_TRUE"));*/
    1192   if (uids_are_stored == SL_TRUE)
     1201  /* SL_REQUIRE(uids_are_stored == S_TRUE, _("uids_are_stored == S_TRUE"));*/
     1202  if (uids_are_stored == S_TRUE)
    11931203    return (euid);
    11941204  else
    … …  
    12031213{
    12041214  SL_ENTER(_("sl_get_egid"));
    1205   /* SL_REQUIRE(uids_are_stored == SL_TRUE, _("uids_are_stored == SL_TRUE"));*/
    1206   if (uids_are_stored == SL_TRUE)
     1215  /* SL_REQUIRE(uids_are_stored == S_TRUE, _("uids_are_stored == S_TRUE"));*/
     1216  if (uids_are_stored == S_TRUE)
    12071217    *ret = egid;
    12081218  else
    … …  
    12181228{
    12191229  SL_ENTER(_("sl_get_ruid"));
    1220   /* SL_REQUIRE(uids_are_stored == SL_TRUE, _("uids_are_stored == SL_TRUE"));*/
    1221   if (uids_are_stored == SL_TRUE)
     1230  /* SL_REQUIRE(uids_are_stored == S_TRUE, _("uids_are_stored == S_TRUE"));*/
     1231  if (uids_are_stored == S_TRUE)
    12221232    *ret = ruid;
    12231233  else
    … …  
    12331243{
    12341244  SL_ENTER(_("sl_get_rgid"));
    1235   /* SL_REQUIRE(uids_are_stored == SL_TRUE, _("uids_are_stored == SL_TRUE"));*/
    1236   if (uids_are_stored == SL_TRUE)
     1245  /* SL_REQUIRE(uids_are_stored == S_TRUE, _("uids_are_stored == S_TRUE"));*/
     1246  if (uids_are_stored == S_TRUE)
    12371247    *ret = rgid;
    12381248  else
    … …  
    12481258{
    12491259  SL_ENTER(_("sl_get_ruid_orig"));
    1250   /* SL_REQUIRE(uids_are_stored == SL_TRUE, _("uids_are_stored == SL_TRUE"));*/
    1251   if (uids_are_stored == SL_TRUE)
     1260  /* SL_REQUIRE(uids_are_stored == S_TRUE, _("uids_are_stored == S_TRUE"));*/
     1261  if (uids_are_stored == S_TRUE)
    12521262    *ret = ruid_orig;
    12531263  else
    … …  
    12631273{
    12641274  SL_ENTER(_("sl_get_rgid_orig"));
    1265   /* SL_REQUIRE(uids_are_stored == SL_TRUE, _("uids_are_stored == SL_TRUE"));*/
    1266   if (uids_are_stored == SL_TRUE)
     1275  /* SL_REQUIRE(uids_are_stored == S_TRUE, _("uids_are_stored == S_TRUE"));*/
     1276  if (uids_are_stored == S_TRUE)
    12671277    *ret = rgid_orig;
    12681278  else
    … …  
    12891299  SL_ENTER(_("sl_set_suid"));
    12901300
    1291   if (uids_are_stored == SL_FALSE)
     1301  if (uids_are_stored == S_FALSE)
    12921302    {
    12931303      SL_IRETURN(SL_ENONE, _("sl_set_suid"));
    12941304    }
    12951305
    1296   SL_REQUIRE(uids_are_stored == SL_TRUE, _("uids_are_stored == SL_TRUE")); 
     1306  SL_REQUIRE(uids_are_stored == S_TRUE, _("uids_are_stored == S_TRUE")); 
    12971307
    12981308  if (ruid == euid && rgid == egid)
    12991309    {
    1300       suid_is_set = SL_TRUE;
     1310      suid_is_set = S_TRUE;
    13011311      SL_IRETURN(SL_ENONE, _("sl_set_suid"));
    13021312    } 
    1303   SL_REQUIRE(suid_is_set     == SL_FALSE, _("suid_is_set == SL_FALSE")); 
     1313  SL_REQUIRE(suid_is_set     == S_FALSE, _("suid_is_set == S_FALSE")); 
    13041314
    13051315#if defined(HAVE_SETRESUID)
    … …  
    13301340
    13311341  SL_REQUIRE(retval == 0, _("retval == 0"));
    1332   suid_is_set = SL_TRUE;
     1342  suid_is_set = S_TRUE;
    13331343  SL_IRETURN(SL_ENONE, _("sl_set_suid"));
    13341344}
    … …  
    13441354  SL_ENTER(_("sl_unset_suid"));
    13451355
    1346   if (uids_are_stored == SL_FALSE)
     1356  if (uids_are_stored == S_FALSE)
    13471357    {
    13481358      SL_IRETURN(SL_ENONE, _("sl_unset_suid"));
    13491359    }
    13501360
    1351   SL_REQUIRE(uids_are_stored == SL_TRUE, _("uids_are_stored == SL_TRUE"));
     1361  SL_REQUIRE(uids_are_stored == S_TRUE, _("uids_are_stored == S_TRUE"));
    13521362
    13531363  if (ruid == euid && rgid == egid)
    13541364    {
    1355       suid_is_set = SL_FALSE;
     1365      suid_is_set = S_FALSE;
    13561366      SL_IRETURN(SL_ENONE, _("sl_unset_suid"));
    13571367    } 
    1358   SL_REQUIRE(suid_is_set     == SL_TRUE, _("suid_is_set == SL_TRUE")); 
     1368  SL_REQUIRE(suid_is_set     == S_TRUE, _("suid_is_set == S_TRUE")); 
    13591369
    13601370#if defined(HAVE_SETRESUID)
    … …  
    13841394
    13851395  SL_REQUIRE(retval == 0, _("retval == 0"));
    1386   suid_is_set = SL_FALSE;
     1396  suid_is_set = S_FALSE;
    13871397  SL_IRETURN(SL_ENONE, _("sl_unset_suid"));
    13881398}
    … …  
    13951405{
    13961406  SL_ENTER(_("sl_save_uids"));
    1397   if (uids_are_stored == SL_TRUE)
     1407  if (uids_are_stored == S_TRUE)
    13981408    SL_IRETURN(SL_EREPEAT, _("sl_save_uids"));
    13991409
    … …  
    14041414  ruid = ruid_orig;
    14051415  rgid = rgid_orig;
    1406   uids_are_stored = SL_TRUE;
     1416  uids_are_stored = S_TRUE;
    14071417
    14081418  SL_IRETURN(SL_ENONE, _("sl_save_uids"));
    … …  
    14171427{
    14181428  SL_ENTER(_("sl_drop_privileges"));
    1419   SL_REQUIRE(uids_are_stored == SL_TRUE, _("uids_are_stored == SL_TRUE"));
     1429  SL_REQUIRE(uids_are_stored == S_TRUE, _("uids_are_stored == S_TRUE"));
    14201430
    14211431  SL_REQUIRE(setgid(rgid_orig) == 0, _("setgid(rgid_orig) == 0"));
    … …  
    14421452{
    14431453  SL_ENTER(_("sl_policy_get_root"));
    1444   SL_REQUIRE(uids_are_stored == SL_FALSE, _("uids_are_stored == SL_FALSE"));
     1454  SL_REQUIRE(uids_are_stored == S_FALSE, _("uids_are_stored == S_FALSE"));
    14451455
    14461456  SL_REQUIRE (sl_save_uids() == SL_ENONE, _("sl_save_uids() == SL_ENONE"));
    … …  
    14551465      rgid = egid;
    14561466    }
    1457   suid_is_set = SL_TRUE;
     1467  suid_is_set = S_TRUE;
    14581468  if (euid == 0)
    14591469    {
    … …  
    14741484{
    14751485  SL_ENTER(_("sl_policy_get_real"));
    1476   SL_REQUIRE(uids_are_stored == SL_FALSE, _("uids_are_stored == SL_FALSE"));
     1486  SL_REQUIRE(uids_are_stored == S_FALSE, _("uids_are_stored == S_FALSE"));
    14771487  SL_REQUIRE (sl_save_uids() == SL_ENONE, _("sl_save_uids() == SL_ENONE"));
    14781488
    … …  
    15071517              _("sl_drop_privileges() == SL_ENONE"));
    15081518
    1509   suid_is_set = SL_TRUE;
     1519  suid_is_set = S_TRUE;
    15101520  SL_IRETURN(SL_ENONE, _("sl_policy_get_real"));
    15111521}
    … …  
    15221532
    15231533  SL_REQUIRE(user != NULL, _("user != NULL"));
    1524   SL_REQUIRE(uids_are_stored == SL_FALSE, _("uids_are_stored == SL_FALSE"));
     1534  SL_REQUIRE(uids_are_stored == S_FALSE, _("uids_are_stored == S_FALSE"));
    15251535  SL_REQUIRE (sl_save_uids() == SL_ENONE, _("sl_save_uids() == SL_ENONE"));
    15261536
    … …  
    17781788  ofiles[fd]->content = NULL;
    17791789  ofiles[fd]->stream  = stream;
    1780   ofiles[fd]->flush   = SL_FALSE;
     1790  ofiles[fd]->flush   = S_FALSE;
    17811791
    17821792  sl_strlcpy(ofiles[fd]->ofile, ofile, SL_OFILE_SIZE);
    … …  
    20582068  ofiles[fd]->content = NULL;
    20592069  ofiles[fd]->stream  = NULL;
    2060   ofiles[fd]->flush   = SL_FALSE;
     2070  ofiles[fd]->flush   = S_FALSE;
    20612071
    20622072  sl_strlcpy(ofiles[fd]->ofile, ofile, SL_OFILE_SIZE);
    … …  
    21822192#endif
    21832193
    2184 static int sl_drop_cache = SL_FALSE;
     2194static int sl_drop_cache = S_FALSE;
    21852195
    21862196int sl_set_drop_cache(const char * str)
    … …  
    22032213#if defined(HAVE_POSIX_FADVISE) && defined(HAVE_MINCORE) && defined(POSIX_FADV_DONTNEED)
    22042214
    2205   if (SL_FALSE != sl_drop_cache && !SL_ISERROR(status))
     2215  if (S_FALSE != sl_drop_cache && !SL_ISERROR(status))
    22062216    {
    22072217      int fd = get_the_fd(status);
    … …  
    22092219        {
    22102220          if (0 == sl_check_mincore(fd))
    2211             ofiles[fd]->flush = SL_TRUE;
     2221            ofiles[fd]->flush = S_TRUE;
    22122222        }
    22132223    }
    … …  
    23452355    {
    23462356#if defined(HAVE_POSIX_FADVISE) && defined(HAVE_MINCORE) && defined(POSIX_FADV_DONTNEED)
    2347       if (ofiles[fd]->flush == SL_TRUE)
     2357      if (ofiles[fd]->flush == S_TRUE)
    23482358        {
    23492359          posix_fadvise(fd, 0, 0, POSIX_FADV_DONTNEED);
    … …  
    25692579  extern volatile int sig_termfast;
    25702580 
    2571   if (is_nonblocking == SL_FALSE)
     2581  if (is_nonblocking == S_FALSE)
    25722582    {
    25732583      /* set to non-blocking mode
    … …  
    26202630                {
    26212631                  error = errno;
    2622                   if (is_nonblocking == SL_FALSE)
     2632                  if (is_nonblocking == S_FALSE)
    26232633                      retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags);
    26242634                  TPT(( 0, FIL__, __LINE__, _("msg=<read error>")));
    … …  
    26372647      else if (retval == 0)
    26382648        {
    2639           if (is_nonblocking == SL_FALSE)
     2649          if (is_nonblocking == S_FALSE)
    26402650              retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags);
    26412651          TPT(( 0, FIL__, __LINE__, _("msg=<timeout>")));
    … …  
    26482658        {
    26492659          error = errno;
    2650           if (is_nonblocking == SL_FALSE)
     2660          if (is_nonblocking == S_FALSE)
    26512661              retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags);
    26522662          TPT(( 0, FIL__, __LINE__, _("msg=<timeout>")));
    … …  
    26572667      if (sig_termfast == 1)
    26582668        {
    2659           if (is_nonblocking == SL_FALSE)
     2669          if (is_nonblocking == S_FALSE)
    26602670              retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags);
    26612671          TPT(( 0, FIL__, __LINE__, _("msg=<terminated>")));
    … …  
    26692679      if (tdiff > timeout)
    26702680        {
    2671           if (is_nonblocking == SL_FALSE)
     2681          if (is_nonblocking == S_FALSE)
    26722682              retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags);
    26732683          TPT(( 0, FIL__, __LINE__, _("msg=<timeout>")));
    … …  
    26792689    }
    26802690
    2681   if (is_nonblocking == SL_FALSE)
     2691  if (is_nonblocking == S_FALSE)
    26822692    retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags);
    26832693  return ((int) bytes);
    … …  
    28882898
    28892899extern uid_t rootonly[];
    2890 extern int   EUIDSLOT;
    2891 extern int   ORIG_EUIDSLOT;
     2900extern unsigned int   EUIDSLOT;
     2901extern unsigned int   ORIG_EUIDSLOT;
    28922902
    28932903extern char  tf_path[MAXFILENAME];      /* Error path for trust function. */
    … …  
    29983008int  sl_trust_purge_user (void)
    29993009{
    3000   int i;
     3010  unsigned int i;
    30013011
    30023012  EUIDSLOT = ORIG_EUIDSLOT;
    … …  
    30743084{
    30753085  long          status;
    3076   static time_t old = 0;
    3077   static time_t now;
     3086  static size_t old = 0;
     3087  static size_t now;
    30783088
    30793089  SL_ENTER(_("sl_trustfile_euid"));
    … …  
    30843094
    30853095  now = time(NULL);
     3096
    30863097  if (now < (old + 300))
    30873098    {
    … …  
    31193130{
    31203131  if ((b == 0) || (a >= (INT_MIN / b) && a <= (INT_MAX / b)))
    3121     return SL_TRUE; /* no overflow */
    3122   return SL_FALSE;
     3132    return S_TRUE; /* no overflow */
     3133  return S_FALSE;
    31233134}
    31243135
    … …  
    31263137{
    31273138  if ((b == 0) || (a <= (SIZE_MAX / b)))
    3128     return SL_TRUE; /* no overflow */
    3129   return SL_FALSE;
     3139    return S_TRUE; /* no overflow */
     3140  return S_FALSE;
    31303141}
    31313142
    … …  
    31343145  (void) a;
    31353146  if (b != 0)
    3136     return SL_TRUE; /* no overflow */
    3137   return SL_FALSE;
     3147    return S_TRUE; /* no overflow */
     3148  return S_FALSE;
    31383149}
    31393150
    … …  
    31433154    {
    31443155      if (a <= (INT_MAX - b))
    3145         return SL_TRUE; /* no overflow */
     3156        return S_TRUE; /* no overflow */
    31463157      else
    3147         return SL_FALSE;
     3158        return S_FALSE;
    31483159    }
    31493160  else if (a < 0 && b < 0)
    31503161    {
    31513162      if (a >= (INT_MIN - b))
    3152         return SL_TRUE; /* no overflow */
     3163        return S_TRUE; /* no overflow */
    31533164      else
    3154         return SL_FALSE;
    3155     }
    3156   return SL_TRUE;
     3165        return S_FALSE;
     3166    }
     3167  return S_TRUE;
    31573168}
    31583169
    … …  
    31603171{
    31613172  if (a <= (SIZE_MAX - b))
    3162     return SL_TRUE; /* no overflow */
     3173    return S_TRUE; /* no overflow */
    31633174  else
    3164     return SL_FALSE;
     3175    return S_FALSE;
    31653176}
    31663177
    … …  
    31703181    {
    31713182      if (a <= (INT_MAX + b))
    3172         return SL_TRUE; /* no overflow */
     3183        return S_TRUE; /* no overflow */
    31733184      else
    3174         return SL_FALSE;
     3185        return S_FALSE;
    31753186    }
    31763187  else if (a < 0 && b >= 0)
    31773188    {
    31783189      if (a >= (INT_MIN + b))
    3179         return SL_TRUE; /* no overflow */
     3190        return S_TRUE; /* no overflow */
    31803191      else
    3181         return SL_FALSE;
    3182     }
    3183   return SL_TRUE;
    3184 }
     3192        return S_FALSE;
     3193    }
     3194  return S_TRUE;
     3195}

  • trunk/src/t-test1.c

    r454 r481  
    230230                if(m->size > 0) free(m->ptr);
    231231                m->ptr = (unsigned char *)memalign(sizeof(int) << r, size);
    232                 /* fprintf(stderr, "FIXME memalign %p\n", m->ptr); */
    233232                ++n_memalign;
    234233        } else if(r < 20) { /* calloc */
    … …  
    246245#endif
    247246                ++n_calloc;
    248                 /* fprintf(stderr, "FIXME calloc %p\n", m->ptr); */
    249247        } else if(r < 100 && m->size < REALLOC_MAX) { /* realloc */
    250248                if(m->size == 0) m->ptr = NULL;
    251249                m->ptr = realloc(m->ptr, size);
    252                 /* fprintf(stderr, "FIXME realloc %p\n", m->ptr); */
    253250                ++n_realloc;
    254251        } else { /* plain malloc */
    255252                if(m->size > 0) free(m->ptr);
    256253                m->ptr = (unsigned char *)malloc(size);
    257                 /* fprintf(stderr, "FIXME malloc %p\n", m->ptr); */
    258254                ++n_malloc;
    259255        }

  • trunk/src/trustfile.c

    r474 r481  
    102102
    103103
    104 #ifndef TRUST_MAIN
     104#if !defined(TRUST_MAIN)
    105105
    106106#include "slib.h"
    … …  
    121121
    122122#define TRUST_DEBUG
    123 #define SL_FALSE 0
    124 #define SL_TRUE  1
     123#define S_FALSE 0
     124#define S_TRUE  1
    125125#define SL_ENTER(string)
    126126#define SL_IRETURN(a, b)  return a
    … …  
    222222
    223223uid_t tf_euid = tf_uid_neg;
    224 int EUIDSLOT = sizeof(test_rootonly)/sizeof(uid_t);
    225 int ORIG_EUIDSLOT = sizeof(test_rootonly)/sizeof(uid_t);
     224unsigned int EUIDSLOT = sizeof(test_rootonly)/sizeof(uid_t);
     225unsigned int ORIG_EUIDSLOT = sizeof(test_rootonly)/sizeof(uid_t);
    226226
    227227char  tf_path[MAXFILENAME];             /* error path for trust function */
    … …  
    381381  SL_ENTER(_("isin"));
    382382  if (list == NULL)
    383     SL_IRETURN(SL_FALSE, _("isin"));
     383    SL_IRETURN(S_FALSE, _("isin"));
    384384
    385385  while(*list != tf_uid_neg && *list != n)
    … …  
    400400               (UID_CAST) n);
    401401#endif
    402       SL_IRETURN(SL_FALSE, _("isin"));
     402      SL_IRETURN(S_FALSE, _("isin"));
    403403    }
    404404
    … …  
    408408           (UID_CAST)n, (UID_CAST)*list);
    409409#endif
    410   SL_IRETURN(SL_TRUE, _("isin"));
     410  SL_IRETURN(S_TRUE, _("isin"));
    411411}
    412412
    … …  
    506506  if (pbuffer) free(pbuffer);
    507507#endif
    508   SL_IRETURN(SL_FALSE, _("isingrp"));
     508  SL_IRETURN(S_FALSE, _("isingrp"));
    509509
    510510 end_true:
    … …  
    513513  if (pbuffer) free(pbuffer);
    514514#endif
    515   SL_IRETURN(SL_TRUE, _("isingrp"));
     515  SL_IRETURN(S_TRUE, _("isingrp"));
    516516}
    517517
    … …  
    537537#endif
    538538
    539   int retval = SL_FALSE;
     539  int retval = S_FALSE;
    540540
    541541  SL_ENTER(_("onlytrustedingrp"));
    … …  
    567567              (UID_CAST)grp);
    568568#endif
    569       retval = SL_FALSE;
     569      retval = S_FALSE;
    570570      goto end_retval;
    571571    }
    … …  
    574574   
    575575  if(g->gr_mem == NULL || g->gr_mem[0] == NULL )
    576     SL_IRETURN(SL_TRUE, _("onlytrustedingrp") );
     576    SL_IRETURN(S_TRUE, _("onlytrustedingrp") );
    577577  */
    578578
    … …  
    640640#endif
    641641          tf_baduid = w->pw_uid;
    642           retval = SL_FALSE;
     642          retval = S_FALSE;
    643643#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
    644644          if (pbuffer) free(pbuffer);
    … …  
    698698#endif
    699699              tf_baduid = w->pw_uid;
    700               retval = SL_FALSE;
     700              retval = S_FALSE;
    701701              goto out;
    702               /* SL_IRETURN(SL_FALSE, _("onlytrustedingrp")); */
    703             }
    704         }
    705     }
    706   retval = SL_TRUE;
     702              /* SL_IRETURN(S_FALSE, _("onlytrustedingrp")); */
     703            }
     704        }
     705    }
     706  retval = S_TRUE;
    707707
    708708 out:
    … …  
    720720
    721721#ifdef TRUST_DEBUG
    722   if (retval == SL_TRUE)
     722  if (retval == S_TRUE)
    723723    fprintf(stderr,
    724724            "trustfile: group %ld:  all members are trusted users --> OK\n",
    … …  
    849849          char * csym;                  /* contents of symlink file  */
    850850          char * full;                  /* "full" name of symlink    */
    851           register char *b, *t;         /* used to copy stuff around */
    852           register int lsym;            /* num chars in symlink ref  */
    853           register int i;               /* trustworthy or not?       */
     851          char *b;                      /* used to copy stuff around */
     852          const char *t;                /* used to copy stuff around */
     853          int lsym;                     /* num chars in symlink ref  */
     854          int i;                        /* trustworthy or not?       */
    854855          const char * t_const;
    855856          char *end;
    … …  
    915916              /* smack on the /../
    916917               */
    917               t_const = "/../"; t = (char *)t_const;
     918              t_const = "/../"; t = (const char *)t_const;
    918919              while(*t && b < end)
    919920                *b++ = *t++;
    … …  
    997998       * file regardless of permissions, so bomb
    998999       */
    999       if (((okusers != NULL && SL_FALSE == isin((uid_t)stbuf.st_uid,okusers))||
    1000            (badusers != NULL && SL_TRUE == isin((uid_t)stbuf.st_uid,badusers))))
     1000      if (((okusers != NULL && S_FALSE == isin((uid_t)stbuf.st_uid,okusers))||
     1001           (badusers != NULL && S_TRUE == isin((uid_t)stbuf.st_uid,badusers))))
    10011002        {
    10021003#ifdef TRUST_DEBUG

  • trunk/src/yulectl.c

    r454 r481  
    2424#include <stdlib.h>
    2525#include <string.h>
     26#include <ctype.h>
    2627#include <errno.h>
    2728
    … …  
    4142#define SH_MAXMSG 209
    4243
     44#if !defined(HAVE_GETPEEREID) && !defined(SO_PEERCRED) && \
     45  !defined(HAVE_STRUCT_CMSGCRED) && !defined(HAVE_STRUCT_FCRED) && \
     46  !(defined(HAVE_STRUCT_SOCKCRED) && defined(LOCAL_CREDS))
     47#define SH_REQ_PASSWORD 1
     48#endif
     49
    4350static int    sock     = -1;
    44 static char * sockname = NULL;
    45 
    4651static char   password[15] = "";
    47 
    4852static int    verbose = 0;
    4953
    … …  
    8690
    8791
    88 int
    89 make_named_socket (char * sockname)
     92static int
     93create_unix_socket ()
    9094{
    9195  int sock;
    92 
    93 #if 0
    94   struct sockaddr_un name;
    95   size_t size;
    96 #else
    97   (void) sockname;
    98 #endif
    9996
    10097  /* Create the socket. */
    … …  
    107104    }
    108105
    109 #if 0
    110   /* Bind a name to the socket. */
    111   name.sun_family = AF_FILE;
    112   strcpy (name.sun_path, sockname);
    113 
    114   /* The size of the address is
    115      the offset of the start of the filename,
    116      plus its length,
    117      plus one for the terminating null byte. */
    118   size = (offsetof (struct sockaddr_un, sun_path)
    119           + strlen (name.sun_path) + 1);
    120 
    121   if (bind (sock, (struct sockaddr *) &name, size) < 0)
    122     {
    123       perror (_("ERROR: bind"));
    124       return -1;
    125     }
    126 #endif
    127 
    128106  return sock;
    129107}
    130108
    131 void
     109static void
    132110termination_handler (int signum)
    133111{
    … …  
    138116        fprintf(stdout, _("# Terminated on signal %d\n"), signum);
    139117    }
    140 #if 0
    141   if (sockname != NULL) unlink (sockname);
    142 #endif
    143   if (sock   >= 0 ) close  (sock);
    144 
     118  if (sock   >= 0 )
     119    close  (sock);
    145120  return;
    146121}
    147122
    148 
    149 int send_to_server (char * serversock, char * message)
     123static char * safe_copy(char * to, const char * from, size_t size)
     124{
     125  if (to && from)
     126    {
     127      strncpy (to, from, size);
     128      if (size > 0)
     129        to[size-1] = '\0';
     130      else
     131        *to = '\0';
     132    }
     133  return to;
     134}
     135 
     136
     137static int send_to_server (char * serversock, char * message)
    150138{
    151139  struct sockaddr_un name;
    152   /* size_t size; */
    153140  int size;
    154141  int nbytes;
    … …  
    168155    }
    169156
    170   /* Send the datagram.
    171   nbytes = sendto (sock, message, strlen (message) + 1, 0,
    172                    (struct sockaddr *) & name, size);
     157  /* Send the data.
    173158   */
    174159  nbytes = send (sock, message, strlen (message) + 1, 0);
    175 
    176160  if (nbytes < 0)
    177161    {
    … …  
    205189}
    206190
    207 int recv_from_server (char * message)
     191static int recv_from_server (char * message)
    208192{
    209193  int nbytes = 0;
    … …  
    211195  int  num = 0;
    212196  int  good = -1;
    213   int  islist = 0;
    214197  char * p;
    215198
    216199  if (password[0] == '\0')
    217     {
    218       if (message[0] == 'L' && message[1] == 'I' &&
    219           message[2] == 'S' && message[3] == 'T')
    220         {
    221           islist = 1;
    222         }
    223       if (message[0] == 'P' && message[1] == 'R' &&
    224           message[2] == 'O' && message[3] == 'B' && message[4] == 'E' )
    225         {
    226           islist = 1;
    227         }
    228     }
     200    p = message;
    229201  else
    230     {
    231       p = &message[strlen(password)+1];
    232       if (p[0] == 'L' && p[1] == 'I' &&
    233           p[2] == 'S' && p[3] == 'T')
    234         {
    235           islist = 1;
    236         }
    237       if (p[0] == 'P' && p[1] == 'R' &&
    238           p[2] == 'O' && p[3] == 'B' && p[4] == 'E' )
    239         {
    240           islist = 1;
    241         }
    242     }
    243 
    244   if (islist == 1)
     202    p = &message[strlen(password)+1];
     203
     204  if (0 == strncmp(p, _("PROBE"), 5) ||
     205      0 == strncmp(p, _("LIST"),  4))
    245206    {
    246207      do {
    247         /*
    248         nbytes = recvfrom (sock, recvmsg, SH_MAXMSG, 0, NULL, 0);
    249         */
    250208        nbytes = getline_from_server (sock, recvmsg, SH_MAXMSG);
    251209        if (nbytes < 0)
    252210          {
    253211            if (errno == EAGAIN)
    254               {
    255                 return 0;
    256               }
     212              return 0;
    257213            else
    258214              {
    … …  
    262218          }
    263219        else if (nbytes == 0)
    264           {
    265             return 0;
    266           }
     220          return 0;
     221
    267222        if (recvmsg[0] == 'E' && recvmsg[1] == 'N' && recvmsg[2] == 'D')
    268223          {
    … …  
    277232  else
    278233    {
    279       /*
    280       nbytes = recvfrom (sock, recvmsg, SH_MAXMSG, 0, NULL, 0);
    281       */
    282234      nbytes = recv (sock, recvmsg, SH_MAXMSG, 0);
    283235      if (nbytes < 0)
    … …  
    290242  /* Print a diagnostic message. */
    291243  if (password[0] == '\0')
    292     {
    293       good = strcmp (message, recvmsg);
    294     }
     244    good = strcmp (message, recvmsg);
    295245  else
    296     {
    297       good = strcmp (&message[strlen(password)+1], recvmsg);
    298     }
     246    good = strcmp (&message[strlen(password)+1], recvmsg);
    299247
    300248  if (0 != good)
    301249    {
    302       fprintf (stderr, "%s", _("ERROR: Bounced message != original message (possible reason: superfluous password).\n"));
     250      if (0 == strncmp(recvmsg, _("!E:"), 3))
     251        {
     252          fputs(recvmsg, stderr);
     253          fputc('\n', stderr);
     254        }
     255      else
     256        {
     257          fputs (_("ERROR: Bounced message != original message.\n"), stderr);
     258        }
    303259      return -1;
    304260    }
    … …  
    312268}
    313269
    314 void usage(char * name)
     270static int check_uuid(const char * in)
     271{
     272  int           i;
     273  const char    *cp;
     274
     275  if (!in || strlen(in) != 36)
     276    return -1;
     277  for (i=0, cp = in; i <= 36; i++,cp++) {
     278    if ((i == 8) || (i == 13) || (i == 18) ||
     279        (i == 23)) {
     280      if (*cp == '-')
     281        continue;
     282      else
     283        return -1;
     284    }
     285    if (i== 36)
     286      if (*cp == 0)
     287        continue;
     288    if (!isxdigit(*cp))
     289      return -1;
     290  }
     291  return 0;
     292}
     293
     294static int check_command(const char * str)
     295{
     296  unsigned int i = 0;
     297  char * commands[] = { N_("DELTA:"), N_("RELOAD"),  N_("STOP"), N_("SCAN"),
     298                        N_("CANCEL"), N_("LISTALL"), N_("LIST"), N_("PROBE"), NULL };
     299
     300  while (commands[i])
     301    {
     302      size_t len = strlen(_(commands[i]));
     303
     304      if (0 == strncmp(_(commands[i]), str, len))
     305        {
     306          if (i == 0)
     307            {
     308              char * p = strchr(str, ':'); ++p;
     309              if ( 0 == check_uuid(p) )
     310                return 0;
     311            }
     312          else
     313            {
     314              if (len == strlen(str))
     315                return 0;
     316            }
     317        }
     318      ++i;
     319    }
     320
     321  fprintf (stderr, _("ERROR: invalid command <%s>\n\n"), str);
     322  return -1;
     323}
     324
     325static void print_usage_and_exit(char * name, int exit_status)
    315326{
    316327  printf(_("\nUsage : %s [-v][-s server_socket] -c command <client_hostname>\n\n"),
    … …  
    325336  printf("%s", _("          variable YULECTL_PASSWORD (not recommended).\n\n"));
    326337
    327   printf("%s", _("Commands: RELOAD    <reload configuration>\n"));
    328   printf("%s", _("          STOP      <terminate>\n"));
    329   printf("%s", _("          SCAN      <initiate file system check\n"));
    330   printf("%s", _("          CANCEL    <cancel previous command>\n"));
    331   printf("%s", _("          LIST      <list queued commands>\n"));
    332   printf("%s", _("          LISTALL   <list queued and last sent commands>\n"));
    333   printf("%s", _("          PROBE     <probe all clients for necessity of reload>\n"));
    334   return;
     338  printf("%s", _("Commands: RELOAD         reload configuration\n"));
     339  printf("%s", _("          DELTA:<uuid>   load delta database with given uuid\n"));
     340  printf("%s", _("          STOP           terminate\n"));
     341  printf("%s", _("          SCAN           initiate file system check\n"));
     342  printf("%s", _("          CANCEL         cancel pending command(s)\n"));
     343  printf("%s", _("          LIST           list queued commands\n"));
     344  printf("%s", _("          LISTALL        list queued and last sent commands\n"));
     345  printf("%s", _("          PROBE          probe all clients for necessity of reload\n"));
     346  exit(exit_status);
    335347}
    336348
    … …  
    339351  size_t len;
    340352
    341   if (!str)
    342     return str;
     353  if (!str) return str;
    343354
    344355  len = strlen(str);
    … …  
    351362        break;
    352363    }
    353    
    354364  return str;
    355365}
    356366
    357 void fixup_message (char * message)
    358 {
    359   char message2[SH_MAXMSG];
    360   char home[4096];
    361   FILE * fp;
     367static int get_home(char * home, size_t size)
     368{
    362369  struct passwd * pwent;
    363   char * pw;
    364 
    365   pw = getenv(_("YULECTL_PASSWORD"));
    366   if (pw && strlen(pw) < 15)
    367     {
    368       strcpy(password, pw);
    369       strcpy(message2, password);
    370       goto do_msg;
    371     }
    372  
     370
    373371  pwent = getpwuid(geteuid());
    374372  if ((pwent == 0) || (pwent->pw_dir == NULL))
    … …  
    379377      if (NULL != getenv(_("HOME")))
    380378        {
    381           strncpy(home, getenv(_("HOME")), 4096);
    382           home[4095] = '\0';
     379          safe_copy(home, getenv(_("HOME")), size);
    383380        }
    384381      else
    385382        {
    386383          fprintf (stderr, _("ERROR: no home directory for euid %ld (tried $HOME and password database).\n"), (long) geteuid());
    387           exit(EXIT_FAILURE);
     384          return -1;
    388385        }
    389386    }
    390387  else
    391388    {
    392       strncpy(home, pwent->pw_dir, 4096);
    393       home[4095] = '\0';
    394     }
     389      safe_copy(home, pwent->pw_dir, size);
     390    }
     391  return 0;
     392}
     393
     394static int get_passwd(char * message2, size_t size)
     395{
     396  char home[4096];
     397  FILE * fp;
     398  char * pw;
     399
     400  /* 1) Password from environment
     401   */
     402  pw = getenv(_("YULECTL_PASSWORD"));
     403  if (pw && strlen(pw) < 15)
     404    {
     405      strcpy(password, pw);
     406      strcpy(message2, password);
     407      return 0;
     408    }
     409
     410  /* 2) Password from $HOME/.yule_cred
     411   */
     412  if (get_home(home, sizeof(home)) < 0)
     413    return -1;
    395414
    396415  if ( (strlen(home) + strlen(_("/.yulectl_cred")) + 1) > 4096)
    397416    {
    398417      fprintf (stderr, "%s", _("ERROR: path for $HOME is too long.\n"));
    399       exit(EXIT_FAILURE);
     418      return -1;
    400419    }
    401420  strcat(home, _("/.yulectl_cred"));
    402421  fp = fopen(home, "r");
    403422
    404 #if !defined(HAVE_GETPEEREID) && !defined(SO_PEERCRED) && !defined(HAVE_STRUCT_CMSGCRED) && !defined(HAVE_STRUCT_FCRED) && !(defined(HAVE_STRUCT_SOCKCRED) && defined(LOCAL_CREDS))
     423#if defined(SH_REQ_PASSWORD)
    405424  if (fp == NULL)
    406425    {
    … …  
    415434                 home, (long)geteuid(), (long)getuid());
    416435      }
    417       exit(EXIT_FAILURE);
     436      return -1;
    418437    }
    419438#else
    420439  if (fp == NULL)
    421     return;
     440    return 0;
    422441#endif
    423442
    424   if (NULL == fgets(message2, sizeof(message2), fp))
     443  if (NULL == fgets(message2, size, fp))
    425444    {
    426445      fprintf (stderr,
    427446               _("ERROR: empty or unreadable password file (%s).\n"),
    428447               home);
    429       exit(EXIT_FAILURE);
     448      return -1;
    430449    }
    431450
    … …  
    436455      fprintf (stderr, "%s",
    437456               _("ERROR: Password too long (max. 14 characters).\n"));
    438       exit(EXIT_FAILURE);
    439     }
    440 
     457      return -1;
     458    }
    441459  strcpy(password, message2);
    442460  fclose(fp);
    443461
    444  do_msg:
    445   strcat(message2, "@");
    446 
    447   strncat(message2, message, SH_MAXMSG - strlen(message2) -1);
    448   message2[SH_MAXMSG-1] = '\0';
    449   strcpy(message, message2);
     462  return 0;
     463}
     464
     465static int fixup_message (char * message)
     466{
     467  char message_fixed[SH_MAXMSG] = { 0 };
     468
     469  if (get_passwd(message_fixed, sizeof(message_fixed)) < 0)
     470    return -1;
     471
     472  if (strlen(message_fixed) > 0)
     473    {
     474      strcat(message_fixed, "@");
     475
     476      strncat(message_fixed, message, SH_MAXMSG - strlen(message_fixed) -1);
     477      message_fixed[SH_MAXMSG-1] = '\0';
     478      strcpy(message, message_fixed);
     479    }
     480  return 0;
     481}
     482
     483static int fill_serversock(char * serversock, size_t size)
     484{
     485  int status;
     486
     487#ifdef HAVE_VSNPRINTF
     488  status = snprintf(serversock, size, _("%s/%s.sock"),
     489                    DEFAULT_PIDDIR, SH_INSTALL_NAME);
     490#else
     491  if ((strlen(DEFAULT_PIDDIR) + strlen(SH_INSTALL_NAME) + 1 + 6) > size)
     492    status = -1;
     493  else
     494    status = sprintf (serversock, _("%s/%s.sock"),
     495                      DEFAULT_PIDDIR, SH_INSTALL_NAME);
     496#endif
     497
     498  if ((status < 0) || (status > (int)(size-1)))
     499    {
     500      fprintf(stderr, _("ERROR: Path too long (maximum %d): %s/%s.sock\n"),
     501              (int) (size-1), DEFAULT_PIDDIR, SH_INSTALL_NAME);
     502      return -1;
     503    }
     504  return 0;
     505}
     506
     507static void checklen(char * command, char * str, size_t maxlen)
     508{
     509  if (strlen(str) > maxlen)
     510    {
     511      fprintf(stderr, _("ERROR: String too long (max %d): %s\n\n"),
     512              (int) maxlen, str);
     513      print_usage_and_exit (command, EXIT_FAILURE);
     514    }
    450515  return;
    451516}
    452517
     518static void checknull(char * command, char * str)
     519{
     520  if (str == NULL || str[0] == '\0') {
     521    fprintf(stderr, "%s", _("ERROR: option with missing argument\n\n"));
     522    print_usage_and_exit(command, EXIT_FAILURE);
     523  }
     524  return;
     525}
    453526
    454527int
    … …  
    457530
    458531  char   message[SH_MAXMSG] = "";
    459   char   clientcd[1024];
    460532  char   serversock[256];
    461   int    status, size;
     533  int    status;
    462534  int    num = 1;
    463535  int    flag = 0;
    464  
    465 #ifdef HAVE_VSNPRINTF
    466   status = snprintf(serversock, 256, _("%s/%s.sock"),
    467                     DEFAULT_PIDDIR, SH_INSTALL_NAME);
    468 #else
    469   if ((strlen(DEFAULT_PIDDIR) + strlen(SH_INSTALL_NAME) + 1 + 6) > 256)
    470     {
    471       status = -1;
    472     }
    473   else
    474     {
    475       status = sprintf (serversock, _("%s/%s.sock"),
    476                         DEFAULT_PIDDIR, SH_INSTALL_NAME);
    477     }
    478 #endif
    479 
    480   if ((status < 0) || (status > 255))
    481     {
    482       fprintf(stderr, _("ERROR: Path too long (maximum 255): %s/%s.sock\n"),
    483               DEFAULT_PIDDIR, SH_INSTALL_NAME);
    484       return (EXIT_FAILURE);
    485     }
     536
     537  if (fill_serversock(serversock, sizeof(serversock)) < 0)
     538    return (EXIT_FAILURE);
     539
    486540
    487541  while (argc > 1 && argv[num][0] == '-')
    … …  
    490544        {
    491545          case 'h':
    492             usage(argv[0]);
    493             return (EXIT_SUCCESS);
    494 
     546            print_usage_and_exit(argv[0], EXIT_SUCCESS);
     547            break;
    495548          case 'v':
    496549            ++verbose;
    497550            break;
    498 
    499551          case 's':
    500552            --argc; ++num;
    501             if (argv[num] == NULL || argv[num][0] == '\0') {
    502               usage(argv[0]);
    503               fprintf(stderr, "%s", _("ERROR: -s: argument missing\n"));
    504               return (EXIT_FAILURE);
    505             } else {
    506               if (strlen(argv[num]) > 255)
    507                 {
    508                   fprintf(stderr, _("ERROR: Path too long: %s\n"), argv[num]);
    509                   return (EXIT_FAILURE);
    510                 }
    511               strncpy (serversock, argv[num], 256);
    512               serversock[255] = '\0';
    513             }
     553            checknull(argv[0], argv[num]);
     554            checklen(argv[0], argv[num], sizeof(serversock)-1);
     555            safe_copy (serversock, argv[num], sizeof(serversock));
    514556            break;
    515 
    516557          case 'c':
    517558            --argc; ++num;
    518             if (argv[num] == NULL || argv[num][0] == '\0') {
    519               usage(argv[0]);
    520               fprintf(stderr, "%s", _("ERROR: -c: argument missing\n"));
    521               return (EXIT_FAILURE);
    522             } else {
    523               if (strlen(argv[num]) >= SH_MAXMSG)
    524                 {
    525                   fprintf(stderr, _("ERROR: Command too long: %s\n"),
    526                           argv[num]);
    527                   return (EXIT_FAILURE);
    528                 }
    529               strncpy (message, argv[num], SH_MAXMSG);
    530               message[SH_MAXMSG-1] = '\0';
    531               strncat(message, ":", SH_MAXMSG-strlen(message)-1);
    532               message[SH_MAXMSG-1] = '\0';
    533               flag = 1;
    534             }
     559            checknull(argv[0], argv[num]);
     560            checklen(argv[0], argv[num], SH_MAXMSG-1);
     561            if (0 != check_command(argv[num]))
     562              print_usage_and_exit(argv[0], EXIT_FAILURE);
     563            safe_copy(message, argv[num], SH_MAXMSG);
     564            strncat(message, ":", SH_MAXMSG-strlen(message)-1);
     565            message[SH_MAXMSG-1] = '\0';
     566            flag = 1;
    535567            break;
    536 
    537568          default:
    538             usage(argv[0]);
    539             fprintf(stderr, _("ERROR: unknown option -%c\n"), argv[num][1]);
    540             return (EXIT_FAILURE);
     569            fprintf(stderr, _("ERROR: unknown option -%c\n\n"), argv[num][1]);
     570            print_usage_and_exit(argv[0], EXIT_FAILURE);
     571            break;
    541572        }
    542573      --argc; ++num;
    … …  
    544575
    545576  if (flag == 0) /* no command given */
    546     {
    547       usage(argv[0]);
    548       return (EXIT_FAILURE);
    549     }
     577    print_usage_and_exit(argv[0], EXIT_FAILURE);
    550578
    551579  if (argc > 1)
    552580    {
    553       if (strlen(argv[num]) > (SH_MAXMSG - strlen(message) -1))
    554         {
    555           fprintf(stderr, _("ERROR: Hostname too long: %s\n"), argv[num]);
    556           return (EXIT_FAILURE);
    557         }
    558       strncat (message, argv[num], SH_MAXMSG -strlen(message) - 1);
     581      checklen(argv[0], argv[num], SH_MAXMSG - strlen(message) - 1);
     582      strncat (message, argv[num], SH_MAXMSG - strlen(message) - 1);
    559583      message[SH_MAXMSG-1] = '\0';
    560584    }
    561585  else
    562586    {
    563       if (message[0] == 'P' && message[1] == 'R' &&
    564           message[2] == 'O' && message[3] == 'B' && message[4] == 'E' )
     587      if (0 == strncmp(message, _("PROBE"), 5) ||
     588          0 == strncmp(message, _("LIST"),  4))
    565589        {
    566590          strncat (message, _("dummy"), SH_MAXMSG -strlen(message) - 1);
    567591          message[SH_MAXMSG-1] = '\0';
    568592        }
    569       else if (message[0] == 'L' && message[1] == 'I' &&
    570                message[2] == 'S' && message[3] == 'T')
    571         {
    572           strncat (message, _("dummy"), SH_MAXMSG -strlen(message) - 1);
    573           message[SH_MAXMSG-1] = '\0';
    574         }
    575593      else
    576594        {
    577595          fprintf(stderr, "%s", _("ERROR: this command requires a hostname\n"));
    578           usage(argv[0]);
    579           return (EXIT_FAILURE);
    580         }
    581     }
    582 
    583   fixup_message(message);
    584 
    585   /* OpenBSD wants >= 1024
    586    */
    587   if (NULL == getcwd(clientcd, 1024))
    588     {
    589       perror(_("ERROR: getcwd"));
    590       return (EXIT_FAILURE);
    591     }
    592   size = strlen(clientcd) + 1 + strlen(CLIENT) + 6;
    593   sockname = calloc(1,size);
    594   if (!sockname)
    595     {
    596       perror(_("ERROR: main: malloc"));
    597       return (EXIT_FAILURE);
    598     }
    599 #ifdef HAVE_VSNPRINTF
    600   snprintf(sockname, size, _("%s/%s.sock"), clientcd, CLIENT);
    601 #else
    602   sprintf(sockname, _("%s/%s.sock"), clientcd, CLIENT);
    603 #endif
     596          print_usage_and_exit(argv[0], EXIT_FAILURE);
     597        }
     598    }
     599
     600  if (fixup_message(message) < 0)
     601    return (EXIT_FAILURE);
    604602
    605603  /* Make the socket.
    606604   */
    607   sock = make_named_socket (sockname);
     605  sock = create_unix_socket ();
    608606  if (sock < 0)
    609     {
    610       return (EXIT_FAILURE);
    611     }
     607    return (EXIT_FAILURE);
    612608
    613609  /* Set up termination handler.
    … …  
    630626  /* Wait for a reply.
    631627   */
    632   if (message[0] == 'L' && message[1] == 'I' &&
    633       message[2] == 'S' && message[3] == 'T')
    634     {
    635       if (verbose)
     628  if (verbose)
     629    {
     630      if (0 == strncmp(message, "LIST", 4))
    636631        fprintf(stdout, "%s", _("# Waiting for listing.\n"));
    637     }
    638   else
    639     {
    640       if (verbose)
     632      else
    641633        fprintf(stdout, "%s", _("# Waiting for confirmation.\n"));
    642634    }
     635
    643636  status = recv_from_server (message);
    644637
    645638  if (status < 0)
    646639    {
    647       fprintf(stderr, "%s", _("ERROR: receiving data from server failed.\n"));
     640      fputs(_("ERROR: unexpected or no reply from server.\n"), stderr);
    648641      (void) termination_handler(0);
    649642      return (EXIT_FAILURE);

  • trunk/src/zAVLTree.c

    r474 r481  
    4040}
    4141
    42 static char * dummy_zfree_string;
     42char * dummy_zfree_string;
    4343#ifdef __clang__
    44 static char * dummy_zfree_str;
     44char * dummy_zfree_str;
    4545#endif
    4646
    … …  
    145145  if (tree->keytype == zAVL_KEY_STRING)
    146146    {
    147       return (strcmp((char*)a, (char *)b));
     147      return (strcmp((const char*)a, (const char *)b));
    148148    }
    149149  else /* zAVL_KEY_INT */
    150150    {
    151       int x = *((int *)a);
    152       int y = *((int *)b);
     151      const int x = *((const int *)a);
     152      const int y = *((const int *)b);
    153153
    154154      if      (x > y) return  1;
Note: See TracChangeset for help on using the changeset viewer.