generator/generator_daemon.ml

   1 (* libguestfs
   2  * Copyright (C) 2009-2010 Red Hat Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17  *)
  18
  19 (* Please read generator/README first. *)
  20
  21 open Printf
  22
  23 open Generator_types
  24 open Generator_utils
  25 open Generator_pr
  26 open Generator_docstrings
  27 open Generator_optgroups
  28 open Generator_actions
  29 open Generator_structs
  30 open Generator_c
  31
  32 (* Generate daemon/actions.h. *)
  33 let generate_daemon_actions_h () =
  34   generate_header CStyle GPLv2plus;
  35
  36   pr "#include \"guestfs_protocol.h\"\n";
  37   pr "\n";
  38
  39   List.iter (
  40     function
  41     | shortname, (_, _, (_::_ as optargs)), _, _, _, _, _ ->
  42         iteri (
  43           fun i arg ->
  44             let uc_shortname = String.uppercase shortname in
  45             let n = name_of_argt arg in
  46             let uc_n = String.uppercase n in
  47             pr "#define GUESTFS_%s_%s_BITMASK (UINT64_C(1)<<%d)\n"
  48               uc_shortname uc_n i
  49         ) optargs
  50     | _ -> ()
  51   ) daemon_functions;
  52
  53   List.iter (
  54     fun (name, (ret, args, optargs), _, _, _, _, _) ->
  55       let style = ret, args @ optargs, [] in
  56       generate_prototype
  57         ~single_line:true ~newline:true ~in_daemon:true ~prefix:"do_"
  58         name style;
  59   ) daemon_functions
  60
  61 (* Generate the server-side stubs. *)
  62 and generate_daemon_actions () =
  63   generate_header CStyle GPLv2plus;
  64
  65   pr "#include <config.h>\n";
  66   pr "\n";
  67   pr "#include <stdio.h>\n";
  68   pr "#include <stdlib.h>\n";
  69   pr "#include <string.h>\n";
  70   pr "#include <inttypes.h>\n";
  71   pr "#include <rpc/types.h>\n";
  72   pr "#include <rpc/xdr.h>\n";
  73   pr "\n";
  74   pr "#include \"daemon.h\"\n";
  75   pr "#include \"c-ctype.h\"\n";
  76   pr "#include \"guestfs_protocol.h\"\n";
  77   pr "#include \"actions.h\"\n";
  78   pr "\n";
  79
  80   List.iter (
  81     fun (name, (ret, args, optargs), _, _, _, _, _) ->
  82       (* Generate server-side stubs. *)
  83       pr "static void %s_stub (XDR *xdr_in)\n" name;
  84       pr "{\n";
  85       (match ret with
  86        | RErr | RInt _ -> pr "  int r;\n"
  87        | RInt64 _ -> pr "  int64_t r;\n"
  88        | RBool _ -> pr "  int r;\n"
  89        | RConstString _ | RConstOptString _ ->
  90            failwithf "RConstString|RConstOptString cannot be used by daemon functions"
  91        | RString _ -> pr "  char *r;\n"
  92        | RStringList _ | RHashtable _ -> pr "  char **r;\n"
  93        | RStruct (_, typ) -> pr "  guestfs_int_%s *r;\n" typ
  94        | RStructList (_, typ) -> pr "  guestfs_int_%s_list *r;\n" typ
  95        | RBufferOut _ ->
  96            pr "  size_t size = 1;\n";
  97            pr "  char *r;\n"
  98       );
  99
 100       if args <> [] || optargs <> [] then (
 101         pr "  struct guestfs_%s_args args;\n" name;
 102         List.iter (
 103           function
 104           | Device n | Dev_or_Path n
 105           | Pathname n
 106           | String n
 107           | Key n -> ()
 108           | OptString n -> pr "  char *%s;\n" n
 109           | StringList n | DeviceList n -> pr "  char **%s;\n" n
 110           | Bool n -> pr "  int %s;\n" n
 111           | Int n -> pr "  int %s;\n" n
 112           | Int64 n -> pr "  int64_t %s;\n" n
 113           | FileIn _ | FileOut _ -> ()
 114           | BufferIn n ->
 115               pr "  const char *%s;\n" n;
 116               pr "  size_t %s_size;\n" n
 117           | Pointer _ -> assert false
 118         ) (args @ optargs)
 119       );
 120       pr "\n";
 121
 122       let is_filein =
 123         List.exists (function FileIn _ -> true | _ -> false) args in
 124
 125       (* Reject unknown optional arguments.
 126        * Note this code is included even for calls with no optional
 127        * args because the caller must not pass optargs_bitmask != 0
 128        * in that case.
 129        *)
 130       if optargs <> [] then (
 131         let len = List.length optargs in
 132         let mask = Int64.lognot (Int64.pred (Int64.shift_left 1L len)) in
 133         pr "  if (optargs_bitmask & UINT64_C(0x%Lx)) {\n" mask;
 134         if is_filein then
 135           pr "    cancel_receive ();\n";
 136         pr "    reply_with_error (\"unknown option in optional arguments bitmask (this can happen if a program is compiled against a newer version of libguestfs, then run against an older version of the daemon)\");\n";
 137         pr "    goto done;\n";
 138         pr "  }\n";
 139       ) else (
 140         pr "  if (optargs_bitmask != 0) {\n";
 141         if is_filein then
 142           pr "    cancel_receive ();\n";
 143         pr "    reply_with_error (\"header optargs_bitmask field must be passed as 0 for calls that don't take optional arguments\");\n";
 144         pr "    goto done;\n";
 145         pr "  }\n";
 146       );
 147       pr "\n";
 148
 149       (* Decode arguments. *)
 150       if args <> [] || optargs <> [] then (
 151         pr "  memset (&args, 0, sizeof args);\n";
 152         pr "\n";
 153         pr "  if (!xdr_guestfs_%s_args (xdr_in, &args)) {\n" name;
 154         if is_filein then
 155           pr "    cancel_receive ();\n";
 156         pr "    reply_with_error (\"daemon failed to decode procedure arguments\");\n";
 157         pr "    goto done;\n";
 158         pr "  }\n";
 159         let pr_args n =
 160           pr "  char *%s = args.%s;\n" n n
 161         in
 162         let pr_list_handling_code n =
 163           pr "  %s = realloc (args.%s.%s_val,\n" n n n;
 164           pr "                sizeof (char *) * (args.%s.%s_len+1));\n" n n;
 165           pr "  if (%s == NULL) {\n" n;
 166           if is_filein then
 167             pr "    cancel_receive ();\n";
 168           pr "    reply_with_perror (\"realloc\");\n";
 169           pr "    goto done;\n";
 170           pr "  }\n";
 171           pr "  %s[args.%s.%s_len] = NULL;\n" n n n;
 172           pr "  args.%s.%s_val = %s;\n" n n n;
 173         in
 174         List.iter (
 175           function
 176           | Pathname n ->
 177               pr_args n;
 178               pr "  ABS_PATH (%s, %s, goto done);\n"
 179                 n (if is_filein then "cancel_receive ()" else "");
 180           | Device n ->
 181               pr_args n;
 182               pr "  RESOLVE_DEVICE (%s, %s, goto done);\n"
 183                 n (if is_filein then "cancel_receive ()" else "");
 184           | Dev_or_Path n ->
 185               pr_args n;
 186               pr "  REQUIRE_ROOT_OR_RESOLVE_DEVICE (%s, %s, goto done);\n"
 187                 n (if is_filein then "cancel_receive ()" else "");
 188           | String n | Key n -> pr_args n
 189           | OptString n -> pr "  %s = args.%s ? *args.%s : NULL;\n" n n n
 190           | StringList n ->
 191               pr_list_handling_code n;
 192           | DeviceList n ->
 193               pr_list_handling_code n;
 194               pr "  /* Ensure that each is a device,\n";
 195               pr "   * and perform device name translation.\n";
 196               pr "   */\n";
 197               pr "  {\n";
 198               pr "    size_t i;\n";
 199               pr "    for (i = 0; %s[i] != NULL; ++i)\n" n;
 200               pr "      RESOLVE_DEVICE (%s[i], %s, goto done);\n" n
 201                 (if is_filein then "cancel_receive ()" else "");
 202               pr "  }\n";
 203           | Bool n -> pr "  %s = args.%s;\n" n n
 204           | Int n -> pr "  %s = args.%s;\n" n n
 205           | Int64 n -> pr "  %s = args.%s;\n" n n
 206           | FileIn _ | FileOut _ -> ()
 207           | BufferIn n ->
 208               pr "  %s = args.%s.%s_val;\n" n n n;
 209               pr "  %s_size = args.%s.%s_len;\n" n n n
 210           | Pointer _ -> assert false
 211         ) (args @ optargs);
 212         pr "\n"
 213       );
 214
 215       (* this is used at least for do_equal *)
 216       if List.exists (function Pathname _ -> true | _ -> false) args then (
 217         (* Emit NEED_ROOT just once, even when there are two or
 218            more Pathname args *)
 219         pr "  NEED_ROOT (%s, goto done);\n"
 220           (if is_filein then "cancel_receive ()" else "");
 221       );
 222
 223       (* Don't want to call the impl with any FileIn or FileOut
 224        * parameters, since these go "outside" the RPC protocol.
 225        *)
 226       let () =
 227         let args' =
 228           List.filter
 229             (function FileIn _ | FileOut _ -> false | _ -> true) args in
 230         let style = ret, args' @ optargs, [] in
 231         pr "  r = do_%s " name;
 232         generate_c_call_args style;
 233         pr ";\n" in
 234
 235       (match ret with
 236        | RConstOptString _ -> assert false
 237        | RErr | RInt _ | RInt64 _ | RBool _
 238        | RConstString _
 239        | RString _ | RStringList _ | RHashtable _
 240        | RStruct (_, _) | RStructList (_, _) ->
 241            let errcode =
 242              match errcode_of_ret ret with
 243              | `CannotReturnError -> assert false
 244              | (`ErrorIsMinusOne | `ErrorIsNULL) as e -> e in
 245            pr "  if (r == %s)\n" (string_of_errcode errcode);
 246            pr "    /* do_%s has already called reply_with_error */\n" name;
 247            pr "    goto done;\n";
 248            pr "\n"
 249        | RBufferOut _ ->
 250            pr "  /* size == 0 && r == NULL could be a non-error case (just\n";
 251            pr "   * an ordinary zero-length buffer), so be careful ...\n";
 252            pr "   */\n";
 253            pr "  if (size == 1 && r == NULL)\n";
 254            pr "    /* do_%s has already called reply_with_error */\n" name;
 255            pr "    goto done;\n";
 256            pr "\n"
 257       );
 258
 259       (* If there are any FileOut parameters, then the impl must
 260        * send its own reply.
 261        *)
 262       let no_reply =
 263         List.exists (function FileOut _ -> true | _ -> false) args in
 264       if no_reply then
 265         pr "  /* do_%s has already sent a reply */\n" name
 266       else (
 267         match ret with
 268         | RErr -> pr "  reply (NULL, NULL);\n"
 269         | RInt n | RInt64 n | RBool n ->
 270             pr "  struct guestfs_%s_ret ret;\n" name;
 271             pr "  ret.%s = r;\n" n;
 272             pr "  reply ((xdrproc_t) &xdr_guestfs_%s_ret, (char *) &ret);\n"
 273               name
 274         | RConstString _ | RConstOptString _ ->
 275             failwithf "RConstString|RConstOptString cannot be used by daemon functions"
 276         | RString n ->
 277             pr "  struct guestfs_%s_ret ret;\n" name;
 278             pr "  ret.%s = r;\n" n;
 279             pr "  reply ((xdrproc_t) &xdr_guestfs_%s_ret, (char *) &ret);\n"
 280               name;
 281             pr "  free (r);\n"
 282         | RStringList n | RHashtable n ->
 283             pr "  struct guestfs_%s_ret ret;\n" name;
 284             pr "  ret.%s.%s_len = count_strings (r);\n" n n;
 285             pr "  ret.%s.%s_val = r;\n" n n;
 286             pr "  reply ((xdrproc_t) &xdr_guestfs_%s_ret, (char *) &ret);\n"
 287               name;
 288             pr "  free_strings (r);\n"
 289         | RStruct (n, _) ->
 290             pr "  struct guestfs_%s_ret ret;\n" name;
 291             pr "  ret.%s = *r;\n" n;
 292             pr "  free (r);\n";
 293             pr "  reply ((xdrproc_t) xdr_guestfs_%s_ret, (char *) &ret);\n"
 294               name;
 295             pr "  xdr_free ((xdrproc_t) xdr_guestfs_%s_ret, (char *) &ret);\n"
 296               name
 297         | RStructList (n, _) ->
 298             pr "  struct guestfs_%s_ret ret;\n" name;
 299             pr "  ret.%s = *r;\n" n;
 300             pr "  free (r);\n";
 301             pr "  reply ((xdrproc_t) xdr_guestfs_%s_ret, (char *) &ret);\n"
 302               name;
 303             pr "  xdr_free ((xdrproc_t) xdr_guestfs_%s_ret, (char *) &ret);\n"
 304               name
 305         | RBufferOut n ->
 306             pr "  struct guestfs_%s_ret ret;\n" name;
 307             pr "  ret.%s.%s_val = r;\n" n n;
 308             pr "  ret.%s.%s_len = size;\n" n n;
 309             pr "  reply ((xdrproc_t) &xdr_guestfs_%s_ret, (char *) &ret);\n"
 310               name;
 311             pr "  free (r);\n"
 312       );
 313
 314       (* Free the args. *)
 315       pr "done:\n";
 316       (match args with
 317        | [] -> ()
 318        | _ ->
 319            pr "  xdr_free ((xdrproc_t) xdr_guestfs_%s_args, (char *) &args);\n"
 320              name
 321       );
 322       pr "  return;\n";
 323       pr "}\n\n";
 324   ) daemon_functions;
 325
 326   (* Dispatch function. *)
 327   pr "void dispatch_incoming_message (XDR *xdr_in)\n";
 328   pr "{\n";
 329   pr "  switch (proc_nr) {\n";
 330
 331   List.iter (
 332     fun (name, _, _, _, _, _, _) ->
 333       pr "    case GUESTFS_PROC_%s:\n" (String.uppercase name);
 334       pr "      %s_stub (xdr_in);\n" name;
 335       pr "      break;\n"
 336   ) daemon_functions;
 337
 338   pr "    default:\n";
 339   pr "      reply_with_error (\"dispatch_incoming_message: unknown procedure number %%d, set LIBGUESTFS_PATH to point to the matching libguestfs appliance directory\", proc_nr);\n";
 340   pr "  }\n";
 341   pr "}\n";
 342   pr "\n";
 343
 344   (* LVM columns and tokenization functions. *)
 345   (* XXX This generates crap code.  We should rethink how we
 346    * do this parsing.
 347    *)
 348   List.iter (
 349     function
 350     | typ, cols ->
 351         pr "static const char *lvm_%s_cols = \"%s\";\n"
 352           typ (String.concat "," (List.map fst cols));
 353         pr "\n";
 354
 355         pr "static int lvm_tokenize_%s (char *str, guestfs_int_lvm_%s *r)\n" typ typ;
 356         pr "{\n";
 357         pr "  char *tok, *p, *next;\n";
 358         pr "  size_t i, j;\n";
 359         pr "\n";
 360         (*
 361           pr "  fprintf (stderr, \"%%s: <<%%s>>\\n\", __func__, str);\n";
 362           pr "\n";
 363         *)
 364         pr "  if (!str) {\n";
 365         pr "    fprintf (stderr, \"%%s: failed: passed a NULL string\\n\", __func__);\n";
 366         pr "    return -1;\n";
 367         pr "  }\n";
 368         pr "  if (!*str || c_isspace (*str)) {\n";
 369         pr "    fprintf (stderr, \"%%s: failed: passed a empty string or one beginning with whitespace\\n\", __func__);\n";
 370         pr "    return -1;\n";
 371         pr "  }\n";
 372         pr "  tok = str;\n";
 373         List.iter (
 374           fun (name, coltype) ->
 375             pr "  if (!tok) {\n";
 376             pr "    fprintf (stderr, \"%%s: failed: string finished early, around token %%s\\n\", __func__, \"%s\");\n" name;
 377             pr "    return -1;\n";
 378             pr "  }\n";
 379             pr "  p = strchrnul (tok, ',');\n";
 380             pr "  if (*p) next = p+1; else next = NULL;\n";
 381             pr "  *p = '\\0';\n";
 382             (match coltype with
 383              | FString ->
 384                  pr "  r->%s = strdup (tok);\n" name;
 385                  pr "  if (r->%s == NULL) {\n" name;
 386                  pr "    perror (\"strdup\");\n";
 387                  pr "    return -1;\n";
 388                  pr "  }\n"
 389              | FUUID ->
 390                  pr "  for (i = j = 0; i < 32; ++j) {\n";
 391                  pr "    if (tok[j] == '\\0') {\n";
 392                  pr "      fprintf (stderr, \"%%s: failed to parse UUID from '%%s'\\n\", __func__, tok);\n";
 393                  pr "      return -1;\n";
 394                  pr "    } else if (tok[j] != '-')\n";
 395                  pr "      r->%s[i++] = tok[j];\n" name;
 396                  pr "  }\n";
 397              | FBytes ->
 398                  pr "  if (sscanf (tok, \"%%\"SCNu64, &r->%s) != 1) {\n" name;
 399                  pr "    fprintf (stderr, \"%%s: failed to parse size '%%s' from token %%s\\n\", __func__, tok, \"%s\");\n" name;
 400                  pr "    return -1;\n";
 401                  pr "  }\n";
 402              | FInt64 ->
 403                  pr "  if (sscanf (tok, \"%%\"SCNi64, &r->%s) != 1) {\n" name;
 404                  pr "    fprintf (stderr, \"%%s: failed to parse int '%%s' from token %%s\\n\", __func__, tok, \"%s\");\n" name;
 405                  pr "    return -1;\n";
 406                  pr "  }\n";
 407              | FOptPercent ->
 408                  pr "  if (tok[0] == '\\0')\n";
 409                  pr "    r->%s = -1;\n" name;
 410                  pr "  else if (sscanf (tok, \"%%f\", &r->%s) != 1) {\n" name;
 411                  pr "    fprintf (stderr, \"%%s: failed to parse float '%%s' from token %%s\\n\", __func__, tok, \"%s\");\n" name;
 412                  pr "    return -1;\n";
 413                  pr "  }\n";
 414              | FBuffer | FInt32 | FUInt32 | FUInt64 | FChar ->
 415                  assert false (* can never be an LVM column *)
 416             );
 417             pr "  tok = next;\n";
 418         ) cols;
 419
 420         pr "  if (tok != NULL) {\n";
 421         pr "    fprintf (stderr, \"%%s: failed: extra tokens at end of string\\n\", __func__);\n";
 422         pr "    return -1;\n";
 423         pr "  }\n";
 424         pr "  return 0;\n";
 425         pr "}\n";
 426         pr "\n";
 427
 428         pr "guestfs_int_lvm_%s_list *\n" typ;
 429         pr "parse_command_line_%ss (void)\n" typ;
 430         pr "{\n";
 431         pr "  char *out, *err;\n";
 432         pr "  char *p, *pend;\n";
 433         pr "  int r, i;\n";
 434         pr "  guestfs_int_lvm_%s_list *ret;\n" typ;
 435         pr "  void *newp;\n";
 436         pr "\n";
 437         pr "  ret = malloc (sizeof *ret);\n";
 438         pr "  if (!ret) {\n";
 439         pr "    reply_with_perror (\"malloc\");\n";
 440         pr "    return NULL;\n";
 441         pr "  }\n";
 442         pr "\n";
 443         pr "  ret->guestfs_int_lvm_%s_list_len = 0;\n" typ;
 444         pr "  ret->guestfs_int_lvm_%s_list_val = NULL;\n" typ;
 445         pr "\n";
 446         pr "  r = command (&out, &err,\n";
 447         pr "           \"lvm\", \"%ss\",\n" typ;
 448         pr "           \"-o\", lvm_%s_cols, \"--unbuffered\", \"--noheadings\",\n" typ;
 449         pr "           \"--nosuffix\", \"--separator\", \",\", \"--units\", \"b\", NULL);\n";
 450         pr "  if (r == -1) {\n";
 451         pr "    reply_with_error (\"%%s\", err);\n";
 452         pr "    free (out);\n";
 453         pr "    free (err);\n";
 454         pr "    free (ret);\n";
 455         pr "    return NULL;\n";
 456         pr "  }\n";
 457         pr "\n";
 458         pr "  free (err);\n";
 459         pr "\n";
 460         pr "  /* Tokenize each line of the output. */\n";
 461         pr "  p = out;\n";
 462         pr "  i = 0;\n";
 463         pr "  while (p) {\n";
 464         pr "    pend = strchr (p, '\\n');       /* Get the next line of output. */\n";
 465         pr "    if (pend) {\n";
 466         pr "      *pend = '\\0';\n";
 467         pr "      pend++;\n";
 468         pr "    }\n";
 469         pr "\n";
 470         pr "    while (*p && c_isspace (*p))    /* Skip any leading whitespace. */\n";
 471         pr "      p++;\n";
 472         pr "\n";
 473         pr "    if (!*p) {                      /* Empty line?  Skip it. */\n";
 474         pr "      p = pend;\n";
 475         pr "      continue;\n";
 476         pr "    }\n";
 477         pr "\n";
 478         pr "    /* Allocate some space to store this next entry. */\n";
 479         pr "    newp = realloc (ret->guestfs_int_lvm_%s_list_val,\n" typ;
 480         pr "                sizeof (guestfs_int_lvm_%s) * (i+1));\n" typ;
 481         pr "    if (newp == NULL) {\n";
 482         pr "      reply_with_perror (\"realloc\");\n";
 483         pr "      free (ret->guestfs_int_lvm_%s_list_val);\n" typ;
 484         pr "      free (ret);\n";
 485         pr "      free (out);\n";
 486         pr "      return NULL;\n";
 487         pr "    }\n";
 488         pr "    ret->guestfs_int_lvm_%s_list_val = newp;\n" typ;
 489         pr "\n";
 490         pr "    /* Tokenize the next entry. */\n";
 491         pr "    r = lvm_tokenize_%s (p, &ret->guestfs_int_lvm_%s_list_val[i]);\n" typ typ;
 492         pr "    if (r == -1) {\n";
 493         pr "      reply_with_error (\"failed to parse output of '%ss' command\");\n" typ;
 494         pr "      free (ret->guestfs_int_lvm_%s_list_val);\n" typ;
 495         pr "      free (ret);\n";
 496         pr "      free (out);\n";
 497         pr "      return NULL;\n";
 498         pr "    }\n";
 499         pr "\n";
 500         pr "    ++i;\n";
 501         pr "    p = pend;\n";
 502         pr "  }\n";
 503         pr "\n";
 504         pr "  ret->guestfs_int_lvm_%s_list_len = i;\n" typ;
 505         pr "\n";
 506         pr "  free (out);\n";
 507         pr "  return ret;\n";
 508         pr "}\n"
 509
 510   ) ["pv", lvm_pv_cols; "vg", lvm_vg_cols; "lv", lvm_lv_cols]
 511
 512 (* Generate a list of function names, for debugging in the daemon.. *)
 513 and generate_daemon_names () =
 514   generate_header CStyle GPLv2plus;
 515
 516   pr "#include <config.h>\n";
 517   pr "\n";
 518   pr "#include \"daemon.h\"\n";
 519   pr "\n";
 520
 521   pr "/* This array is indexed by proc_nr.  See guestfs_protocol.x. */\n";
 522   pr "const char *function_names[] = {\n";
 523   List.iter (
 524     fun (name, _, proc_nr, _, _, _, _) -> pr "  [%d] = \"%s\",\n" proc_nr name
 525   ) daemon_functions;
 526   pr "};\n";
 527
 528 (* Generate the optional groups for the daemon to implement
 529  * guestfs_available.
 530  *)
 531 and generate_daemon_optgroups_c () =
 532   generate_header CStyle GPLv2plus;
 533
 534   pr "#include <config.h>\n";
 535   pr "\n";
 536   pr "#include \"daemon.h\"\n";
 537   pr "#include \"optgroups.h\"\n";
 538   pr "\n";
 539
 540   pr "struct optgroup optgroups[] = {\n";
 541   List.iter (
 542     fun (group, _) ->
 543       pr "  { \"%s\", optgroup_%s_available },\n" group group
 544   ) optgroups;
 545   pr "  { NULL, NULL }\n";
 546   pr "};\n"
 547
 548 and generate_daemon_optgroups_h () =
 549   generate_header CStyle GPLv2plus;
 550
 551   List.iter (
 552     fun (group, _) ->
 553       pr "extern int optgroup_%s_available (void);\n" group
 554   ) optgroups