/mandos/trunk

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

« back to all changes in this revision

Viewing changes to dracut-module/password-agent.c

  • Committer: Teddy Hogeborn
  • Date: 2019-08-02 22:16:53 UTC
  • Revision ID: teddy@recompile.se-20190802221653-ic1iko9hbefzwsk7
Fix bug in server Debian package: Fails to start on first install

There has been a very long-standing bug where installation of the
server (the "mandos" Debian package) would fail to start the server
properly right after installation.  It would work on manual (re)start
after installation, or after reboot, and even after package purge and
reinstall, it would then work the first time.  The problem, it turns
out, is when the new "_mandos" user (and corresponding group) is
created, the D-Bus server is not reloaded, and is therefore not aware
of that user, and does not recognize the user and group name in the
/etc/dbus-1/system.d/mandos.conf file.  The Mandos server, when it
tries to start and access the D-Bus, is then not permitted to connect
to its D-Bus bus name, and disables D-Bus use as a fallback measure;
i.e. the server works, but it is not controllable via D-Bus commands
(via mandos-ctl or mandos-monitor).  The next time the D-Bus daemon is
reloaded for any reason, the new user & group would become visible to
the D-Bus daemon and after that, any restart of the Mandos server
would succeed and it would bind to its D-Bus name properly, and
thereby be visible and controllable by mandos-ctl & mandos-monitor.
This was mostly invisible when using sysvinit, but systemd makes the
problem visible since the systemd service file for the Mandos server
is configured to not consider the Mandos server "started" until the
D-Bus name has been bound; this makes the starting of the service wait
for 90 seconds and then fail with a timeout error.

Fixing this should also make the Debian CI autopkgtest tests work.

* debian/mandos.postinst (configure): After creating (or renaming)
                                      user & group, reload D-Bus
                                      daemon (if present).

Show diffs side-by-side

added added

removed removed

Lines of Context:
1071
1071
  /* "sufficient to read at least one event." - inotify(7) */
1072
1072
  const size_t ievent_size = (sizeof(struct inotify_event)
1073
1073
                              + NAME_MAX + 1);
1074
 
  char ievent_buffer[sizeof(struct inotify_event) + NAME_MAX + 1];
1075
 
  struct inotify_event *ievent = ((struct inotify_event *)
1076
 
                                  ievent_buffer);
 
1074
  struct {
 
1075
    struct inotify_event event;
 
1076
    char name_buffer[NAME_MAX + 1];
 
1077
  } ievent_buffer;
 
1078
  struct inotify_event *const ievent = &ievent_buffer.event;
1077
1079
 
1078
1080
  const ssize_t read_length = read(fd, ievent, ievent_size);
1079
1081
  if(read_length == 0){ /* EOF */
3929
3931
  const size_t ievent_max_size = (sizeof(struct inotify_event)
3930
3932
                                  + NAME_MAX + 1);
3931
3933
  g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);
3932
 
  char ievent_buffer[sizeof(struct inotify_event) + NAME_MAX + 1];
3933
 
  struct inotify_event *ievent = ((struct inotify_event *)
3934
 
                                  ievent_buffer);
 
3934
  struct {
 
3935
    struct inotify_event event;
 
3936
    char name_buffer[NAME_MAX + 1];
 
3937
  } ievent_buffer;
 
3938
  struct inotify_event *const ievent = &ievent_buffer.event;
3935
3939
 
3936
3940
  const char dummy_file_name[] = "ask.dummy_file_name";
3937
3941
  ievent->mask = IN_CLOSE_WRITE;
3939
3943
  memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
3940
3944
  const size_t ievent_size = (sizeof(struct inotify_event)
3941
3945
                              + sizeof(dummy_file_name));
3942
 
  g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),
 
3946
  g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
3943
3947
                  ==, ievent_size);
3944
3948
  g_assert_cmpint(close(pipefds[1]), ==, 0);
3945
3949
 
4022
4026
  const size_t ievent_max_size = (sizeof(struct inotify_event)
4023
4027
                                  + NAME_MAX + 1);
4024
4028
  g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);
4025
 
  char ievent_buffer[sizeof(struct inotify_event) + NAME_MAX + 1];
4026
 
  struct inotify_event *ievent = ((struct inotify_event *)
4027
 
                                  ievent_buffer);
 
4029
  struct {
 
4030
    struct inotify_event event;
 
4031
    char name_buffer[NAME_MAX + 1];
 
4032
  } ievent_buffer;
 
4033
  struct inotify_event *const ievent = &ievent_buffer.event;
4028
4034
 
4029
4035
  const char dummy_file_name[] = "ask.dummy_file_name";
4030
4036
  ievent->mask = IN_MOVED_TO;
4032
4038
  memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4033
4039
  const size_t ievent_size = (sizeof(struct inotify_event)
4034
4040
                              + sizeof(dummy_file_name));
4035
 
  g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),
 
4041
  g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4036
4042
                  ==, ievent_size);
4037
4043
  g_assert_cmpint(close(pipefds[1]), ==, 0);
4038
4044
 
4117
4123
  const size_t ievent_max_size = (sizeof(struct inotify_event)
4118
4124
                                  + NAME_MAX + 1);
4119
4125
  g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);
4120
 
  char ievent_buffer[sizeof(struct inotify_event) + NAME_MAX + 1];
4121
 
  struct inotify_event *ievent = ((struct inotify_event *)
4122
 
                                  ievent_buffer);
 
4126
  struct {
 
4127
    struct inotify_event event;
 
4128
    char name_buffer[NAME_MAX + 1];
 
4129
  } ievent_buffer;
 
4130
  struct inotify_event *const ievent = &ievent_buffer.event;
4123
4131
 
4124
4132
  const char dummy_file_name[] = "ask.dummy_file_name";
4125
4133
  ievent->mask = IN_DELETE;
4127
4135
  memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4128
4136
  const size_t ievent_size = (sizeof(struct inotify_event)
4129
4137
                              + sizeof(dummy_file_name));
4130
 
  g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),
 
4138
  g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4131
4139
                  ==, ievent_size);
4132
4140
  g_assert_cmpint(close(pipefds[1]), ==, 0);
4133
4141
 
4199
4207
  const size_t ievent_max_size = (sizeof(struct inotify_event)
4200
4208
                                  + NAME_MAX + 1);
4201
4209
  g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);
4202
 
  char ievent_buffer[sizeof(struct inotify_event) + NAME_MAX + 1];
4203
 
  struct inotify_event *ievent = ((struct inotify_event *)
4204
 
                                  ievent_buffer);
 
4210
  struct {
 
4211
    struct inotify_event event;
 
4212
    char name_buffer[NAME_MAX + 1];
 
4213
  } ievent_buffer;
 
4214
  struct inotify_event *const ievent = &ievent_buffer.event;
4205
4215
 
4206
4216
  const char dummy_file_name[] = "ignored.dummy_file_name";
4207
4217
  ievent->mask = IN_CLOSE_WRITE;
4209
4219
  memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4210
4220
  const size_t ievent_size = (sizeof(struct inotify_event)
4211
4221
                              + sizeof(dummy_file_name));
4212
 
  g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),
 
4222
  g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4213
4223
                  ==, ievent_size);
4214
4224
  g_assert_cmpint(close(pipefds[1]), ==, 0);
4215
4225
 
4273
4283
  const size_t ievent_max_size = (sizeof(struct inotify_event)
4274
4284
                                  + NAME_MAX + 1);
4275
4285
  g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);
4276
 
  char ievent_buffer[sizeof(struct inotify_event) + NAME_MAX + 1];
4277
 
  struct inotify_event *ievent = ((struct inotify_event *)
4278
 
                                  ievent_buffer);
 
4286
  struct {
 
4287
    struct inotify_event event;
 
4288
    char name_buffer[NAME_MAX + 1];
 
4289
  } ievent_buffer;
 
4290
  struct inotify_event *const ievent = &ievent_buffer.event;
4279
4291
 
4280
4292
  const char dummy_file_name[] = "ignored.dummy_file_name";
4281
4293
  ievent->mask = IN_MOVED_TO;
4283
4295
  memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4284
4296
  const size_t ievent_size = (sizeof(struct inotify_event)
4285
4297
                              + sizeof(dummy_file_name));
4286
 
  g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),
 
4298
  g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4287
4299
                  ==, ievent_size);
4288
4300
  g_assert_cmpint(close(pipefds[1]), ==, 0);
4289
4301
 
4350
4362
  const size_t ievent_max_size = (sizeof(struct inotify_event)
4351
4363
                                  + NAME_MAX + 1);
4352
4364
  g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);
4353
 
  char ievent_buffer[sizeof(struct inotify_event) + NAME_MAX + 1];
4354
 
  struct inotify_event *ievent = ((struct inotify_event *)
4355
 
                                  ievent_buffer);
 
4365
  struct {
 
4366
    struct inotify_event event;
 
4367
    char name_buffer[NAME_MAX + 1];
 
4368
  } ievent_buffer;
 
4369
  struct inotify_event *const ievent = &ievent_buffer.event;
4356
4370
 
4357
4371
  const char dummy_file_name[] = "ignored.dummy_file_name";
4358
4372
  ievent->mask = IN_DELETE;
4360
4374
  memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4361
4375
  const size_t ievent_size = (sizeof(struct inotify_event)
4362
4376
                              + sizeof(dummy_file_name));
4363
 
  g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),
 
4377
  g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4364
4378
                  ==, ievent_size);
4365
4379
  g_assert_cmpint(close(pipefds[1]), ==, 0);
4366
4380