/mandos/release

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/release

« back to all changes in this revision

Viewing changes to plugins.d/splashy.c

First version of a somewhat complete D-Bus server interface.  Also
change user/group name to "_mandos".

* debian/mandos.postinst: Rename old "mandos" user and group to
                          "_mandos"; create "_mandos" user and group
                          if none exist.
* debian/mandos-client.postinst: - '' -

* initramfs-tools-hook: Try "_mandos" before "mandos" as user and
                        group name.

* mandos (_datetime_to_dbus_struct): New; was previously local.
  (Client.started): Renamed to "last_started".  All users changed.
  (Client.started): New; boolean.
  (Client.dbus_object_path): New.
  (Client.check_command): Renamed to "checker_command".  All users
                          changed.
  (Client.__init__): Set and use "self.dbus_object_path".  Set
                     "self.started".
  (Client.start): Update "self.started".  Emit "self.PropertyChanged"
                  signals for both "started" and "last_started".
  (Client.stop): Update "self.started".  Emit "self.PropertyChanged"
                 signal for "started".
  (Client.checker_callback): Take additional "command" argument.  All
                             callers changed. Emit
                             "self.PropertyChanged" signal.
  (Client.bump_timeout): Emit "self.PropertyChanged" signal for
                         "last_checked_ok".
  (Client.start_checker): Emit "self.PropertyChanged" signal for
                          "checker_running".
  (Client.stop_checker): Emit "self.PropertyChanged" signal for
                         "checker_running".
  (Client.still_valid): Bug fix: use "getattr(self, started, False)"
                        instead of "self.started" in case this client
                        object is so new that the "started" attribute
                        has not been created yet.
  (Client.IntervalChanged, Client.CheckerIsRunning, Client.GetChecker,
  Client.GetCreated, Client.GetFingerprint, Client.GetHost,
  Client.GetInterval, Client.GetName, Client.GetStarted,
  Client.GetTimeout, Client.StateChanged, Client.TimeoutChanged):
  Removed; all callers changed.
  (Client.CheckerCompleted): Add "condition" and "command" arguments.
                             All callers changed.
  (Client.GetAllProperties, Client.PropertyChanged): New.
  (Client.StillValid): Renamed to "IsStillValid".
  (Client.StartChecker): Changed to its own function to avoid the
                         return value from "Client.start_checker()".
  (Client.Stop): Changed to its own function to avoid the return value
                 from "Client.stop()".
  (main): Try "_mandos" before "mandos" as user and group name.
          Removed inner function "remove_from_clients".  New inner
          class "MandosServer".

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/splashy.c
1
1
/*  -*- coding: utf-8 -*- */
2
2
/*
3
 
 * Splashy - Read a password from splashy and output it
 
3
 * Passprompt - Read a password from splashy and output it
4
4
 * 
5
 
 * Copyright © 2008-2011 Teddy Hogeborn
6
 
 * Copyright © 2008-2011 Björn Påhlsson
 
5
 * Copyright © 2008 Teddy Hogeborn
 
6
 * Copyright © 2008 Björn Påhlsson
7
7
 * 
8
8
 * This program is free software: you can redistribute it and/or
9
9
 * modify it under the terms of the GNU General Public License as
19
19
 * along with this program.  If not, see
20
20
 * <http://www.gnu.org/licenses/>.
21
21
 * 
22
 
 * Contact the authors at <mandos@recompile.se>.
 
22
 * Contact the authors at <https://www.fukt.bsnet.se/~belorn/> and
 
23
 * <https://www.fukt.bsnet.se/~teddy/>.
23
24
 */
24
25
 
25
 
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), asprintf() */
 
26
#define _GNU_SOURCE             /* asprintf() */
26
27
#include <signal.h>             /* sig_atomic_t, struct sigaction,
27
28
                                   sigemptyset(), sigaddset(), SIGINT,
28
29
                                   SIGHUP, SIGTERM, sigaction,
29
30
                                   SIG_IGN, kill(), SIGKILL */
30
31
#include <stddef.h>             /* NULL */
31
32
#include <stdlib.h>             /* getenv() */
32
 
#include <stdio.h>              /* asprintf(), vasprintf(), vprintf(),
33
 
                                   fprintf() */
34
 
#include <stdlib.h>             /* EXIT_FAILURE, free(),
 
33
#include <stdio.h>              /* asprintf(), perror() */
 
34
#include <stdlib.h>             /* EXIT_FAILURE, free(), strtoul(),
35
35
                                   EXIT_SUCCESS */
36
36
#include <sys/types.h>          /* pid_t, DIR, struct dirent,
37
37
                                   ssize_t */
38
38
#include <dirent.h>             /* opendir(), readdir(), closedir() */
39
 
#include <inttypes.h>           /* intmax_t, strtoimax() */
40
39
#include <sys/stat.h>           /* struct stat, lstat(), S_ISLNK */
41
40
#include <iso646.h>             /* not, or, and */
42
41
#include <unistd.h>             /* readlink(), fork(), execl(),
43
42
                                   sleep(), dup2() STDERR_FILENO,
44
 
                                   STDOUT_FILENO, _exit(),
45
 
                                   pause() */
46
 
#include <string.h>             /* memcmp(), strerror() */
47
 
#include <errno.h>              /* errno, EACCES, ENOTDIR, ELOOP,
48
 
                                   ENOENT, ENAMETOOLONG, EMFILE,
49
 
                                   ENFILE, ENOMEM, ENOEXEC, EINVAL,
50
 
                                   E2BIG, EFAULT, EIO, ETXTBSY,
51
 
                                   EISDIR, ELIBBAD, EPERM, EINTR,
52
 
                                   ECHILD */
53
 
#include <error.h>              /* error() */
 
43
                                   STDOUT_FILENO, _exit() */
 
44
#include <string.h>             /* memcmp() */
 
45
#include <errno.h>              /* errno */
54
46
#include <sys/wait.h>           /* waitpid(), WIFEXITED(),
55
47
                                   WEXITSTATUS() */
56
 
#include <sysexits.h>           /* EX_OSERR, EX_OSFILE,
57
 
                                   EX_UNAVAILABLE */
58
 
#include <stdarg.h>             /* va_list, va_start(), ... */
59
48
 
60
49
sig_atomic_t interrupted_by_signal = 0;
61
 
int signal_received;
62
 
 
63
 
/* Function to use when printing errors */
64
 
void error_plus(int status, int errnum, const char *formatstring,
65
 
                ...){
66
 
  va_list ap;
67
 
  char *text;
68
 
  int ret;
69
 
  
70
 
  va_start(ap, formatstring);
71
 
  ret = vasprintf(&text, formatstring, ap);
72
 
  if (ret == -1){
73
 
    fprintf(stderr, "Mandos plugin %s: ",
74
 
            program_invocation_short_name);
75
 
    vfprintf(stderr, formatstring, ap);
76
 
    fprintf(stderr, ": ");
77
 
    fprintf(stderr, "%s\n", strerror(errnum));
78
 
    error(status, errno, "vasprintf while printing error");
79
 
    return;
80
 
  }
81
 
  fprintf(stderr, "Mandos plugin ");
82
 
  error(status, errnum, "%s", text);
83
 
  free(text);
84
 
}
85
 
 
86
 
 
87
 
static void termination_handler(int signum){
88
 
  if(interrupted_by_signal){
89
 
    return;
90
 
  }
 
50
 
 
51
static void termination_handler(__attribute__((unused))int signum){
91
52
  interrupted_by_signal = 1;
92
 
  signal_received = signum;
93
53
}
94
54
 
95
55
int main(__attribute__((unused))int argc,
96
56
         __attribute__((unused))char **argv){
97
57
  int ret = 0;
 
58
  
 
59
  /* Create prompt string */
98
60
  char *prompt = NULL;
99
 
  DIR *proc_dir = NULL;
100
 
  pid_t splashy_pid = 0;
101
 
  pid_t splashy_command_pid = 0;
102
 
  int exitstatus = EXIT_FAILURE;
103
 
  
104
 
  /* Create prompt string */
105
61
  {
106
62
    const char *const cryptsource = getenv("cryptsource");
107
63
    const char *const crypttarget = getenv("crypttarget");
124
80
      }
125
81
    }
126
82
    if(ret == -1){
127
 
      prompt = NULL;
128
 
      exitstatus = EX_OSERR;
129
 
      goto failure;
 
83
      return EXIT_FAILURE;
130
84
    }
131
85
  }
132
86
  
133
87
  /* Find splashy process */
 
88
  pid_t splashy_pid = 0;
134
89
  {
135
90
    const char splashy_name[] = "/sbin/splashy";
136
 
    proc_dir = opendir("/proc");
 
91
    DIR *proc_dir = opendir("/proc");
137
92
    if(proc_dir == NULL){
138
 
      int e = errno;
139
 
      error_plus(0, errno, "opendir");
140
 
      switch(e){
141
 
      case EACCES:
142
 
      case ENOTDIR:
143
 
      case ELOOP:
144
 
      case ENOENT:
145
 
      default:
146
 
        exitstatus = EX_OSFILE;
147
 
        break;
148
 
      case ENAMETOOLONG:
149
 
      case EMFILE:
150
 
      case ENFILE:
151
 
      case ENOMEM:
152
 
        exitstatus = EX_OSERR;
153
 
        break;
154
 
      }
155
 
      goto failure;
 
93
      free(prompt);
 
94
      perror("opendir");
 
95
      return EXIT_FAILURE;
156
96
    }
157
97
    for(struct dirent *proc_ent = readdir(proc_dir);
158
98
        proc_ent != NULL;
159
99
        proc_ent = readdir(proc_dir)){
160
 
      pid_t pid;
161
 
      {
162
 
        intmax_t tmpmax;
163
 
        char *tmp;
164
 
        errno = 0;
165
 
        tmpmax = strtoimax(proc_ent->d_name, &tmp, 10);
166
 
        if(errno != 0 or tmp == proc_ent->d_name or *tmp != '\0'
167
 
           or tmpmax != (pid_t)tmpmax){
168
 
          /* Not a process */
169
 
          continue;
170
 
        }
171
 
        pid = (pid_t)tmpmax;
 
100
      pid_t pid = (pid_t) strtoul(proc_ent->d_name, NULL, 10);
 
101
      if(pid == 0){
 
102
        /* Not a process */
 
103
        continue;
172
104
      }
173
105
      /* Find the executable name by doing readlink() on the
174
106
         /proc/<pid>/exe link */
178
110
        char *exe_link;
179
111
        ret = asprintf(&exe_link, "/proc/%s/exe", proc_ent->d_name);
180
112
        if(ret == -1){
181
 
          error_plus(0, errno, "asprintf");
182
 
          exitstatus = EX_OSERR;
183
 
          goto failure;
 
113
          perror("asprintf");
 
114
          free(prompt);
 
115
          closedir(proc_dir);
 
116
          return EXIT_FAILURE;
184
117
        }
185
118
        
186
119
        /* Check that it refers to a symlink owned by root:root */
187
120
        struct stat exe_stat;
188
121
        ret = lstat(exe_link, &exe_stat);
189
122
        if(ret == -1){
190
 
          if(errno == ENOENT){
191
 
            free(exe_link);
192
 
            continue;
193
 
          }
194
 
          int e = errno;
195
 
          error_plus(0, errno, "lstat");
 
123
          perror("lstat");
196
124
          free(exe_link);
197
 
          switch(e){
198
 
          case EACCES:
199
 
          case ENOTDIR:
200
 
          case ELOOP:
201
 
          default:
202
 
            exitstatus = EX_OSFILE;
203
 
            break;
204
 
          case ENAMETOOLONG:
205
 
            exitstatus = EX_OSERR;
206
 
            break;
207
 
          }
208
 
          goto failure;
 
125
          free(prompt);
 
126
          closedir(proc_dir);
 
127
          return EXIT_FAILURE;
209
128
        }
210
129
        if(not S_ISLNK(exe_stat.st_mode)
211
130
           or exe_stat.st_uid != 0
225
144
      }
226
145
    }
227
146
    closedir(proc_dir);
228
 
    proc_dir = NULL;
229
147
  }
230
148
  if(splashy_pid == 0){
231
 
    exitstatus = EX_UNAVAILABLE;
232
 
    goto failure;
 
149
    free(prompt);
 
150
    return EXIT_FAILURE;
233
151
  }
234
152
  
235
153
  /* Set up the signal handler */
238
156
      new_action = { .sa_handler = termination_handler,
239
157
                     .sa_flags = 0 };
240
158
    sigemptyset(&new_action.sa_mask);
241
 
    ret = sigaddset(&new_action.sa_mask, SIGINT);
242
 
    if(ret == -1){
243
 
      error_plus(0, errno, "sigaddset");
244
 
      exitstatus = EX_OSERR;
245
 
      goto failure;
246
 
    }
247
 
    ret = sigaddset(&new_action.sa_mask, SIGHUP);
248
 
    if(ret == -1){
249
 
      error_plus(0, errno, "sigaddset");
250
 
      exitstatus = EX_OSERR;
251
 
      goto failure;
252
 
    }
253
 
    ret = sigaddset(&new_action.sa_mask, SIGTERM);
254
 
    if(ret == -1){
255
 
      error_plus(0, errno, "sigaddset");
256
 
      exitstatus = EX_OSERR;
257
 
      goto failure;
258
 
    }
 
159
    sigaddset(&new_action.sa_mask, SIGINT);
 
160
    sigaddset(&new_action.sa_mask, SIGHUP);
 
161
    sigaddset(&new_action.sa_mask, SIGTERM);
259
162
    ret = sigaction(SIGINT, NULL, &old_action);
260
163
    if(ret == -1){
261
 
      error_plus(0, errno, "sigaction");
262
 
      exitstatus = EX_OSERR;
263
 
      goto failure;
 
164
      perror("sigaction");
 
165
      free(prompt);
 
166
      return EXIT_FAILURE;
264
167
    }
265
168
    if(old_action.sa_handler != SIG_IGN){
266
169
      ret = sigaction(SIGINT, &new_action, NULL);
267
170
      if(ret == -1){
268
 
        error_plus(0, errno, "sigaction");
269
 
        exitstatus = EX_OSERR;
270
 
        goto failure;
 
171
        perror("sigaction");
 
172
        free(prompt);
 
173
        return EXIT_FAILURE;
271
174
      }
272
175
    }
273
176
    ret = sigaction(SIGHUP, NULL, &old_action);
274
177
    if(ret == -1){
275
 
      error_plus(0, errno, "sigaction");
276
 
      exitstatus = EX_OSERR;
277
 
      goto failure;
 
178
      perror("sigaction");
 
179
      free(prompt);
 
180
      return EXIT_FAILURE;
278
181
    }
279
182
    if(old_action.sa_handler != SIG_IGN){
280
183
      ret = sigaction(SIGHUP, &new_action, NULL);
281
184
      if(ret == -1){
282
 
        error_plus(0, errno, "sigaction");
283
 
        exitstatus = EX_OSERR;
284
 
        goto failure;
 
185
        perror("sigaction");
 
186
        free(prompt);
 
187
        return EXIT_FAILURE;
285
188
      }
286
189
    }
287
190
    ret = sigaction(SIGTERM, NULL, &old_action);
288
191
    if(ret == -1){
289
 
      error_plus(0, errno, "sigaction");
290
 
      exitstatus = EX_OSERR;
291
 
      goto failure;
 
192
      perror("sigaction");
 
193
      free(prompt);
 
194
      return EXIT_FAILURE;
292
195
    }
293
196
    if(old_action.sa_handler != SIG_IGN){
294
197
      ret = sigaction(SIGTERM, &new_action, NULL);
295
198
      if(ret == -1){
296
 
        error_plus(0, errno, "sigaction");
297
 
        exitstatus = EX_OSERR;
298
 
        goto failure;
 
199
        perror("sigaction");
 
200
        free(prompt);
 
201
        return EXIT_FAILURE;
299
202
      }
300
203
    }
301
204
  }
302
205
  
303
 
  if(interrupted_by_signal){
304
 
    goto failure;
305
 
  }
306
 
  
307
206
  /* Fork off the splashy command to prompt for password */
308
 
  splashy_command_pid = fork();
309
 
  if(splashy_command_pid != 0 and interrupted_by_signal){
310
 
    goto failure;
311
 
  }
312
 
  if(splashy_command_pid == -1){
313
 
    error_plus(0, errno, "fork");
314
 
    exitstatus = EX_OSERR;
315
 
    goto failure;
316
 
  }
317
 
  /* Child */
318
 
  if(splashy_command_pid == 0){
319
 
    if(not interrupted_by_signal){
 
207
  pid_t splashy_command_pid = 0;
 
208
  if(not interrupted_by_signal){
 
209
    splashy_command_pid = fork();
 
210
    if(splashy_command_pid == -1){
 
211
      if(not interrupted_by_signal){
 
212
        perror("fork");
 
213
      }
 
214
      return EXIT_FAILURE;
 
215
    }
 
216
    /* Child */
 
217
    if(splashy_command_pid == 0){
320
218
      const char splashy_command[] = "/sbin/splashy_update";
321
 
      execl(splashy_command, splashy_command, prompt, (char *)NULL);
322
 
      int e = errno;
323
 
      error_plus(0, errno, "execl");
324
 
      switch(e){
325
 
      case EACCES:
326
 
      case ENOENT:
327
 
      case ENOEXEC:
328
 
      case EINVAL:
329
 
        _exit(EX_UNAVAILABLE);
330
 
      case ENAMETOOLONG:
331
 
      case E2BIG:
332
 
      case ENOMEM:
333
 
      case EFAULT:
334
 
      case EIO:
335
 
      case EMFILE:
336
 
      case ENFILE:
337
 
      case ETXTBSY:
338
 
      default:
339
 
        _exit(EX_OSERR);
340
 
      case ENOTDIR:
341
 
      case ELOOP:
342
 
      case EISDIR:
343
 
#ifdef ELIBBAD
344
 
      case ELIBBAD:             /* Linux only */
345
 
#endif
346
 
      case EPERM:
347
 
        _exit(EX_OSFILE);
 
219
      ret = execl(splashy_command, splashy_command, prompt,
 
220
                  (char *)NULL);
 
221
      if(not interrupted_by_signal){
 
222
        perror("execl");
348
223
      }
 
224
      free(prompt);
 
225
      _exit(EXIT_FAILURE);
349
226
    }
350
 
    free(prompt);
351
 
    _exit(EXIT_FAILURE);
352
227
  }
353
228
  
354
229
  /* Parent */
355
230
  free(prompt);
356
 
  prompt = NULL;
357
 
  
358
 
  if(interrupted_by_signal){
359
 
    goto failure;
360
 
  }
361
231
  
362
232
  /* Wait for command to complete */
363
 
  {
 
233
  if(not interrupted_by_signal and splashy_command_pid != 0){
364
234
    int status;
365
 
    do {
366
 
      ret = waitpid(splashy_command_pid, &status, 0);
367
 
    } while(ret == -1 and errno == EINTR
368
 
            and not interrupted_by_signal);
369
 
    if(interrupted_by_signal){
370
 
      goto failure;
371
 
    }
 
235
    ret = waitpid(splashy_command_pid, &status, 0);
372
236
    if(ret == -1){
373
 
      error_plus(0, errno, "waitpid");
 
237
      if(errno != EINTR){
 
238
        perror("waitpid");
 
239
      }
374
240
      if(errno == ECHILD){
375
241
        splashy_command_pid = 0;
376
242
      }
377
243
    } else {
378
244
      /* The child process has exited */
379
245
      splashy_command_pid = 0;
380
 
      if(WIFEXITED(status) and WEXITSTATUS(status) == 0){
 
246
      if(not interrupted_by_signal and WIFEXITED(status)
 
247
         and WEXITSTATUS(status)==0){
381
248
        return EXIT_SUCCESS;
382
249
      }
383
250
    }
384
251
  }
385
 
  
386
 
 failure:
387
 
  
388
 
  free(prompt);
389
 
  
390
 
  if(proc_dir != NULL){
391
 
    TEMP_FAILURE_RETRY(closedir(proc_dir));
392
 
  }
393
 
  
394
 
  if(splashy_command_pid != 0){
395
 
    TEMP_FAILURE_RETRY(kill(splashy_command_pid, SIGTERM));
396
 
    
397
 
    TEMP_FAILURE_RETRY(kill(splashy_pid, SIGTERM));
398
 
    sleep(2);
399
 
    while(TEMP_FAILURE_RETRY(kill(splashy_pid, 0)) == 0){
400
 
      TEMP_FAILURE_RETRY(kill(splashy_pid, SIGKILL));
401
 
      sleep(1);
402
 
    }
403
 
    pid_t new_splashy_pid = (pid_t)TEMP_FAILURE_RETRY(fork());
404
 
    if(new_splashy_pid == 0){
405
 
      /* Child; will become new splashy process */
406
 
      
407
 
      /* Make the effective user ID (root) the only user ID instead of
408
 
         the real user ID (_mandos) */
409
 
      ret = setuid(geteuid());
410
 
      if(ret == -1){
411
 
        error_plus(0, errno, "setuid");
412
 
      }
413
 
      
414
 
      setsid();
415
 
      ret = chdir("/");
416
 
      if(ret == -1){
417
 
        error_plus(0, errno, "chdir");
418
 
      }
419
 
/*       if(fork() != 0){ */
420
 
/*      _exit(EXIT_SUCCESS); */
421
 
/*       } */
422
 
      ret = dup2(STDERR_FILENO, STDOUT_FILENO); /* replace stdout */
423
 
      if(ret == -1){
424
 
        error_plus(0, errno, "dup2");
425
 
        _exit(EX_OSERR);
426
 
      }
427
 
      
428
 
      execl("/sbin/splashy", "/sbin/splashy", "boot", (char *)NULL);
429
 
      {
430
 
        int e = errno;
431
 
        error_plus(0, errno, "execl");
432
 
        switch(e){
433
 
        case EACCES:
434
 
        case ENOENT:
435
 
        case ENOEXEC:
436
 
        default:
437
 
          _exit(EX_UNAVAILABLE);
438
 
        case ENAMETOOLONG:
439
 
        case E2BIG:
440
 
        case ENOMEM:
441
 
          _exit(EX_OSERR);
442
 
        case ENOTDIR:
443
 
        case ELOOP:
444
 
          _exit(EX_OSFILE);
445
 
        }
446
 
      }
447
 
    }
448
 
  }
449
 
  
450
 
  if(interrupted_by_signal){
451
 
    struct sigaction signal_action;
452
 
    sigemptyset(&signal_action.sa_mask);
453
 
    signal_action.sa_handler = SIG_DFL;
454
 
    ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
455
 
                                            &signal_action, NULL));
456
 
    if(ret == -1){
457
 
      error_plus(0, errno, "sigaction");
458
 
    }
459
 
    do {
460
 
      ret = raise(signal_received);
461
 
    } while(ret != 0 and errno == EINTR);
462
 
    if(ret != 0){
463
 
      error_plus(0, errno, "raise");
464
 
      abort();
465
 
    }
466
 
    TEMP_FAILURE_RETRY(pause());
467
 
  }
468
 
  
469
 
  return exitstatus;
 
252
  kill(splashy_pid, SIGTERM);
 
253
  if(interrupted_by_signal and splashy_command_pid != 0){
 
254
    kill(splashy_command_pid, SIGTERM);
 
255
  }
 
256
  sleep(2);
 
257
  while(kill(splashy_pid, 0) == 0){
 
258
    kill(splashy_pid, SIGKILL);
 
259
    sleep(1);
 
260
  }
 
261
  pid_t new_splashy_pid = fork();
 
262
  if(new_splashy_pid == 0){
 
263
    /* Child; will become new splashy process */
 
264
    
 
265
    /* Make the effective user ID (root) the only user ID instead of
 
266
       the real user ID (mandos) */
 
267
    ret = setuid(geteuid());
 
268
    if(ret == -1){
 
269
      perror("setuid");
 
270
    }
 
271
    
 
272
    setsid();
 
273
    ret = chdir("/");
 
274
/*     if(fork() != 0){ */
 
275
/*       _exit(EXIT_SUCCESS); */
 
276
/*     } */
 
277
    ret = dup2(STDERR_FILENO, STDOUT_FILENO); /* replace our stdout */
 
278
    if(ret == -1){
 
279
      perror("dup2");
 
280
      _exit(EXIT_FAILURE);
 
281
    }
 
282
    
 
283
    execl("/sbin/splashy", "/sbin/splashy", "boot", (char *)NULL);
 
284
    if(not interrupted_by_signal){
 
285
      perror("execl");
 
286
    }
 
287
    _exit(EXIT_FAILURE);
 
288
  }
 
289
  
 
290
  return EXIT_FAILURE;
470
291
}