source3/script/tests/test_net_registry.sh

   1 #!/bin/sh
   2
   3 # Tests for the "net registry" and "net rpc registry" commands.
   4 # rpc tests are chose by specifying "rpc" as commandline parameter.
   5
   6 RPC="$1"
   7
   8 NET="$VALGRIND ${NET:-$BINDIR/net} $CONFIGURATION"
   9
  10 if test "x${RPC}" = "xrpc" ; then
  11         NETREG="${NET} -U${USERNAME}%${PASSWORD} -I ${SERVER_IP} rpc registry"
  12 else
  13         NETREG="${NET} registry"
  14 fi
  15
  16 test x"$TEST_FUNCTIONS_SH" != x"INCLUDED" && {
  17 incdir=`dirname $0`
  18 . $incdir/test_functions.sh
  19 }
  20
  21 failed=0
  22
  23 test_enumerate()
  24 {
  25         KEY="$1"
  26
  27         ${NETREG} enumerate ${KEY}
  28 }
  29
  30 test_getsd()
  31 {
  32         KEY="$1"
  33
  34         ${NETREG} getsd ${KEY}
  35 }
  36
  37 test_enumerate_nonexisting()
  38 {
  39         KEY="$1"
  40         ${NETREG} enumerate ${KEY}
  41
  42         if test "x$?" = "x0" ; then
  43                 echo "ERROR: enumerate succeeded with key '${KEY}'"
  44                 false
  45         else
  46                 true
  47         fi
  48 }
  49
  50 test_enumerate_no_key()
  51 {
  52         ${NETREG} enumerate
  53         if test "x$?" = "x0" ; then
  54                 echo "ERROR: enumerate succeeded without any key spcified"
  55                 false
  56         else
  57                 true
  58         fi
  59 }
  60
  61 test_create_existing()
  62 {
  63         KEY="HKLM"
  64         EXPECTED="createkey opened existing ${KEY}"
  65
  66         OUTPUT=`${NETREG} createkey ${KEY}`
  67         if test "x$?" = "x0" ; then
  68                 if test "$OUTPUT" = "$EXPECTED" ; then
  69                         true
  70                 else
  71                         echo "got '$OUTPUT', expected '$EXPECTED'"
  72                         false
  73                 fi
  74         else
  75                 printf "%s\n" "$OUTPUT"
  76                 false
  77         fi
  78 }
  79
  80 test_createkey()
  81 {
  82         KEY="$1"
  83         BASEKEY=`dirname $KEY`
  84         SUBKEY=`basename $KEY`
  85
  86         OUTPUT=`${NETREG} createkey ${KEY}`
  87         if test "x$?" != "x0" ; then
  88                 echo "ERROR: createkey ${KEY} failed"
  89                 echo "output:"
  90                 printf "%s\n" "$OUTPUT"
  91                 false
  92                 return
  93         fi
  94
  95         # check enumerate of basekey lists new key:
  96         OUTPUT=`${NETREG} enumerate ${BASEKEY}`
  97         if test "x$?" != "x0" ; then
  98                 echo "ERROR: failed to enumerate key '${BASEKEY}'"
  99                 echo "output:"
 100                 printf "%s\n" "$OUTPUT"
 101                 false
 102                 return
 103         fi
 104
 105         EXPECTED="Keyname = ${SUBKEY}"
 106         printf "%s\n" "$OUTPUT" | grep '^Keyname' | grep ${SUBKEY}
 107         if test "x$?" != "x0" ; then
 108                 echo "ERROR: did not find expexted '$EXPECTED' in output"
 109                 echo "output:"
 110                 printf "%s\n" "$OUTPUT"
 111                 false
 112         fi
 113
 114         # check enumerate of new key works:
 115         ${NETREG} enumerate ${KEY}
 116 }
 117
 118 test_deletekey()
 119 {
 120         KEY="$1"
 121         BASEKEY=`dirname ${KEY}`
 122         SUBKEY=`basename ${KEY}`
 123
 124         OUTPUT=`test_createkey "${KEY}"`
 125         if test "x$?" != "x0" ; then
 126                 printf "%s\n" "${OUTPUT}"
 127                 false
 128                 return
 129         fi
 130
 131         OUTPUT=`${NETREG} deletekey ${KEY}`
 132         if test "x$?" != "x0" ; then
 133                 printf "%s\n" "${OUTPUT}"
 134                 false
 135                 return
 136         fi
 137
 138         # check enumerate of basekey does not show key anymore:
 139         OUTPUT=`${NETREG} enumerate ${BASEKEY}`
 140         if test "x$?" != "x0" ; then
 141                 printf "%s\n" "$OUTPUT"
 142                 false
 143                 return
 144         fi
 145
 146         UNEXPECTED="Keyname = ${SUBKEY}"
 147         printf "%s\n" "$OUTPUT" | grep '^Keyname' | grep ${SUBKEY}
 148         if test "x$?" = "x0" ; then
 149                 echo "ERROR: found '$UNEXPECTED' after delete in output"
 150                 echo "output:"
 151                 printf "%s\n" "$OUTPUT"
 152                 false
 153         fi
 154
 155         # check enumerate of key itself does not work anymore:
 156         ${NETREG} enumerate ${KEY}
 157         if test "x$?" = "x0" ; then
 158                 echo "ERROR: 'enumerate ${KEY}' works after 'deletekey ${KEY}'"
 159                 false
 160         else
 161                 true
 162         fi
 163 }
 164
 165 test_deletekey_nonexisting()
 166 {
 167         KEY="$1"
 168
 169         OUTPUT=`test_deletekey "${KEY}"`
 170         if test "x$?" != "x0" ; then
 171                 printf "%s\n" "${OUTPUT}"
 172                 false
 173                 return
 174         fi
 175
 176         ${NETREG} deletekey "${KEY}"
 177         if test "x$?" = "x0" ; then
 178                 echo "ERROR: delete after delete succeeded for key '${KEY}'"
 179                 false
 180         fi
 181 }
 182
 183 test_createkey_with_subkey()
 184 {
 185         KEY="$1"
 186         KEY2=`dirname ${KEY}`
 187         SUBKEYNAME2=`basename ${KEY}`
 188         BASENAME=`dirname ${KEY2}`
 189         SUBKEYNAME1=`basename ${KEY2}`
 190
 191         OUTPUT=`${NETREG} createkey ${KEY}`
 192         if test "x$?" != "x0" ; then
 193                 echo "ERROR: createkey ${KEY} failed"
 194                 printf "%s\n" "${OUTPUT}"
 195                 false
 196                 return
 197         fi
 198
 199         # check we can enumerate to level key
 200         OUTPUT=`${NETREG} enumerate ${KEY}`
 201         if test "x$?" != "x0" ; then
 202                 echo "ERROR: failed to enumerate '${KEY}' after creation"
 203                 printf "%s\n" "${OUTPUT}"
 204                 false
 205                 return
 206         fi
 207
 208         # clear:
 209         ${NETREG} deletekey ${KEY} && ${NETREG} deletekey ${KEY2}
 210 }
 211
 212 test_deletekey_with_subkey()
 213 {
 214         KEY="$1"
 215         KEY2=`dirname ${KEY}`
 216
 217         OUTPUT=`${NETREG} createkey ${KEY}`
 218         if test "x$?" != "x0" ; then
 219                 printf "%s\n" "${OUTPUT}"
 220                 false
 221                 return
 222         fi
 223
 224         OUTPUT=`${NETREG} deletekey ${KEY2}`
 225
 226         if test "x$?" = "x0" ; then
 227                 echo "ERROR: delete of key with subkey succeeded"
 228                 echo "output:"
 229                 printf "%s\n" "$OUTPUT"
 230                 false
 231                 return
 232         fi
 233
 234         ${NETREG} deletekey ${KEY} && ${NETREG} deletekey ${KEY2}
 235 }
 236
 237 test_setvalue()
 238 {
 239         KEY="$1"
 240         VALNAME="${2#_}"
 241         VALTYPE="$3"
 242         VALVALUE="$4"
 243
 244         OUTPUT=`test_createkey ${KEY}`
 245         if test "x$?" != "x0" ; then
 246                 printf "%s\n" "${OUTPUT}"
 247                 false
 248                 return
 249         fi
 250
 251         OUTPUT=`${NETREG} setvalue ${KEY} "${VALNAME}" ${VALTYPE} ${VALVALUE}`
 252         if test "x$?" != "x0" ; then
 253                 echo "ERROR: failed to set value testval in key ${KEY}"
 254                 printf "%s\n" "${OUTPUT}"
 255                 false
 256                 return
 257         fi
 258
 259         OUTPUT=`${NETREG} getvalueraw ${KEY} "${VALNAME}"`
 260         if test "x$?" != "x0" ; then
 261                 echo "ERROR: failure calling getvalueraw for key ${KEY}"
 262                 echo output:
 263                 printf "%s\n" "${OUTPUT}"
 264                 false
 265                 return
 266         fi
 267
 268         if test "x${OUTPUT}" != "x${VALVALUE}" ; then
 269                 echo "ERROR: failure retrieving value ${VALNAME} for key ${KEY}"
 270                 printf "expected: %s\ngot: %s\n" "${VALVALUE}" "${OUTPUT}"
 271                 false
 272                 return
 273         fi
 274
 275 }
 276
 277 test_deletevalue()
 278 {
 279         KEY="$1"
 280         VALNAME="${2#_}"
 281
 282         ${NETREG} deletevalue ${KEY} "${VALNAME}"
 283 }
 284
 285 test_deletevalue_nonexisting()
 286 {
 287         KEY="$1"
 288         VALNAME="${2#_}"
 289
 290         ${NETREG} deletevalue ${KEY} "${VALNAME}"
 291         if test "x$?" = "x0" ; then
 292                 echo "ERROR: succeeded deleting value ${VALNAME}"
 293                 false
 294         else
 295                 true
 296         fi
 297 }
 298
 299 test_setvalue_twice()
 300 {
 301         KEY="$1"
 302         VALNAME="${2#_}"
 303         VALTYPE1="$3"
 304         VALVALUE1="$4"
 305         VALTYPE2="$5"
 306         VALVALUE2="$6"
 307
 308         OUTPUT=`test_setvalue ${KEY} _"${VALNAME}" ${VALTYPE1} ${VALVALUE1}`
 309         if test "x$?" != "x0" ; then
 310                 echo "ERROR: first setvalue call failed"
 311                 printf "%s\n" "$OUTPUT"
 312                 false
 313                 return
 314         fi
 315
 316         ${NETREG} setvalue ${KEY} "${VALNAME}" ${VALTYPE2} ${VALVALUE2}
 317 }
 318
 319 give_administrative_rights()
 320 {
 321         bin/net -s $SERVERCONFFILE sam createbuiltingroup Administrators
 322         if test "x$?" != "x0" ; then
 323                 echo "ERROR: creating builtin group Administrators"
 324                 false
 325                 return
 326         fi
 327
 328         bin/net -s $SERVERCONFFILE sam addmem BUILTIN\\Administrators $USERNAME
 329         if test "x$?" != "x0" ; then
 330                 echo "ERROR: adding user $USERNAME to BUILTIN\\Administrators"
 331                 false
 332         else
 333                 true
 334         fi
 335 }
 336
 337 take_administrative_rights()
 338 {
 339         bin/net -s $SERVERCONFFILE sam delmem BUILTIN\\Administrators $USERNAME
 340         if test "x$?" != "x0" ; then
 341                 echo "ERROR: removing user $USERNAME from BUILTIN\\Administrators"
 342                 false
 343         else
 344                 true
 345         fi
 346 }
 347
 348 if test "x${RPC}" = "xrpc" ; then
 349 testit "giving user ${USERNAME} administrative rights" \
 350         give_administrative_rights
 351         if [ "x$?" != "x0" ] ; then
 352                 failed=`expr $failed + 1`
 353                 testok $0 $failed
 354         fi
 355 fi
 356
 357 testit "enumerate HKLM" \
 358         test_enumerate HKLM || \
 359         failed=`expr $failed + 1`
 360
 361 testit "enumerate nonexisting hive" \
 362         test_enumerate_nonexisting XYZ || \
 363         failed=`expr $failed + 1`
 364
 365 testit "enumerate without key" \
 366         test_enumerate_no_key || \
 367         failed=`expr $failed + 1`
 368
 369 # skip getsd test for registry currently: it fails
 370 if test "x${RPC}" != "xrpc" ; then
 371 testit "getsd HKLM" \
 372         test_getsd HKLM || \
 373         failed=`expr $failed + 1`
 374 fi
 375
 376 testit "create existing HKLM" \
 377         test_create_existing || \
 378         failed=`expr $failed + 1`
 379
 380 testit "create key" \
 381         test_createkey HKLM/testkey || \
 382         failed=`expr $failed + 1`
 383
 384 testit "delete key" \
 385         test_deletekey HKLM/testkey || \
 386         failed=`expr $failed + 1`
 387
 388 testit "delete^2 key" \
 389         test_deletekey_nonexisting HKLM/testkey || \
 390         failed=`expr $failed + 1`
 391
 392 testit "enumerate nonexisting key" \
 393         test_enumerate_nonexisting HKLM/testkey || \
 394         failed=`expr $failed + 1`
 395
 396 testit "create key with subkey" \
 397         test_createkey_with_subkey HKLM/testkey/subkey || \
 398         failed=`expr $failed + 1`
 399
 400 testit "delete key with subkey" \
 401         test_deletekey_with_subkey HKLM/testkey/subkey || \
 402         failed=`expr $failed + 1`
 403
 404 testit "set value" \
 405         test_setvalue HKLM/testkey _testval sz moin || \
 406         failed=`expr $failed + 1`
 407
 408 testit "delete value" \
 409         test_deletevalue HKLM/testkey _testval || \
 410         failed=`expr $failed + 1`
 411
 412 testit "delete nonexisting value" \
 413         test_deletevalue_nonexisting HKLM/testkey _testval || \
 414         failed=`expr $failed + 1`
 415
 416 testit "set value to different type" \
 417         test_setvalue_twice HKLM/testkey testval sz moin dword 42 || \
 418         failed=`expr $failed + 1`
 419
 420 testit "set default value" \
 421         test_setvalue HKLM/testkey _"" sz 42 || \
 422         failed=`expr $failed + 1`
 423
 424 testit "delete default value" \
 425         test_deletevalue HKLM/testkey _"" || \
 426         failed=`expr $failed + 1`
 427
 428 testit "delete nonexisting default value" \
 429         test_deletevalue_nonexisting HKLM/testkey _"" || \
 430         failed=`expr $failed + 1`
 431
 432 testit "delete key with value" \
 433         test_deletekey HKLM/testkey || \
 434         failed=`expr $failed + 1`
 435
 436 if test "x${RPC}" = "xrpc" ; then
 437 testit "taking administrative rights from user ${USERNAME}" \
 438         take_administrative_rights || \
 439         failed=`expr $failed + 1`
 440 fi
 441
 442 testok $0 $failed
 443