source/rpc_client/cli_svcctl.c

   1 /*
   2  *  Unix SMB/Netbios implementation.
   3  *  Version 1.9.
   4  *  RPC Pipe client / server routines
   5  *  Copyright (C) Andrew Tridgell              1992-1998,2000,
   6  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1998,2000,
   7  *  Copyright (C) Paul Ashton                  1997-1998,2000,
   8  *  Copyright (C) Elrond                                 2000.
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25 #include "includes.h"
  26 #include "nterr.h"
  27 #include "rpc_parse.h"
  28 #include "rpc_client.h"
  29
  30 extern int DEBUGLEVEL;
  31
  32 /****************************************************************************
  33 do a SVC Open Policy
  34 ****************************************************************************/
  35 BOOL svc_open_sc_man(const char *srv_name, char *db_name,
  36                      uint32 des_access, POLICY_HND *hnd)
  37 {
  38         prs_struct rbuf;
  39         prs_struct buf;
  40         SVC_Q_OPEN_SC_MAN q_o;
  41         BOOL valid_pol = False;
  42
  43         struct cli_connection *con = NULL;
  44
  45         if (!cli_connection_init(srv_name, PIPE_SVCCTL, &con))
  46         {
  47                 return False;
  48         }
  49
  50         if (hnd == NULL)
  51                 return False;
  52
  53         prs_init(&buf , 0, 4, False);
  54         prs_init(&rbuf, 0, 4, True );
  55
  56         /* create and send a MSRPC command with api SVC_OPEN_SC_MAN */
  57
  58         DEBUG(4, ("SVC Open SC_MAN\n"));
  59
  60         make_svc_q_open_sc_man(&q_o, srv_name, db_name, des_access);
  61
  62         /* turn parameters into data stream */
  63         if (svc_io_q_open_sc_man("", &q_o, &buf, 0) &&
  64             rpc_con_pipe_req(con, SVC_OPEN_SC_MAN, &buf, &rbuf))
  65         {
  66                 SVC_R_OPEN_SC_MAN r_o;
  67                 BOOL p;
  68
  69                 ZERO_STRUCT(r_o);
  70
  71                 svc_io_r_open_sc_man("", &r_o, &rbuf, 0);
  72                 p = rbuf.offset != 0;
  73
  74                 if (p && r_o.status != 0)
  75                 {
  76                         /* report error code */
  77                         DEBUG(1, ("SVC_OPEN_SC_MAN: %s\n",
  78                                   get_nt_error_msg(r_o.status)));
  79                         p = False;
  80                 }
  81
  82                 if (p)
  83                 {
  84                         /* ok, at last: we're happy. return the policy handle */
  85                         *hnd = r_o.pol;
  86                         valid_pol = True;
  87                         valid_pol =
  88                                 register_policy_hnd(get_global_hnd_cache(),
  89                                                     cli_con_sec_ctx(con),
  90                                                     hnd, des_access)
  91                                 && set_policy_con(get_global_hnd_cache(), hnd,
  92                                                   con, cli_connection_unlink);
  93                 }
  94         }
  95
  96         prs_free_data(&rbuf);
  97         prs_free_data(&buf );
  98
  99         return valid_pol;
 100 }
 101
 102
 103 /****************************************************************************
 104 do a SVC Open Service
 105 ****************************************************************************/
 106 BOOL svc_open_service(POLICY_HND *scm_hnd, const char *srv_name,
 107                       uint32 des_access, POLICY_HND *hnd)
 108 {
 109         prs_struct rbuf;
 110         prs_struct buf;
 111         SVC_Q_OPEN_SERVICE q_o;
 112         BOOL valid_pol = False;
 113
 114         struct cli_connection *con = NULL;
 115
 116         if (!cli_connection_get(scm_hnd, &con))
 117         {
 118                 return False;
 119         }
 120
 121         if (hnd == NULL || scm_hnd == NULL)
 122                 return False;
 123
 124         prs_init(&buf , 0, 4, False);
 125         prs_init(&rbuf, 0, 4, True );
 126
 127         /* create and send a MSRPC command with api SVC_OPEN_SERVICE */
 128
 129         DEBUG(4, ("SVC Open Service\n"));
 130
 131         make_svc_q_open_service(&q_o, scm_hnd, srv_name, des_access);
 132
 133         /* turn parameters into data stream */
 134         if (svc_io_q_open_service("", &q_o, &buf, 0) &&
 135             rpc_con_pipe_req(con, SVC_OPEN_SERVICE, &buf, &rbuf))
 136         {
 137                 SVC_R_OPEN_SERVICE r_o;
 138                 BOOL p;
 139
 140                 ZERO_STRUCT(r_o);
 141
 142                 svc_io_r_open_service("", &r_o, &rbuf, 0);
 143                 p = rbuf.offset != 0;
 144
 145                 if (p && r_o.status != 0)
 146                 {
 147                         /* report error code */
 148                         DEBUG(1, ("SVC_OPEN_SC_MAN: %s\n",
 149                                   get_nt_error_msg(r_o.status)));
 150                         p = False;
 151                 }
 152
 153                 if (p)
 154                 {
 155                         /* ok, at last: we're happy. return the policy handle */
 156                         *hnd = r_o.pol;
 157                         valid_pol =
 158                                 register_policy_hnd(get_global_hnd_cache(),
 159                                                     cli_con_sec_ctx(con),
 160                                                     hnd, des_access)
 161                                 && set_policy_con(get_global_hnd_cache(), hnd,
 162                                                   con, NULL);
 163                 }
 164         }
 165
 166         prs_free_data(&rbuf);
 167         prs_free_data(&buf );
 168
 169         return valid_pol;
 170 }
 171
 172
 173 /****************************************************************************
 174 do a SVC Enumerate Services
 175 ****************************************************************************/
 176 BOOL svc_enum_svcs(POLICY_HND *hnd,
 177                    uint32 services_type, uint32 services_state,
 178                    uint32 *buf_size, uint32 *resume_hnd,
 179                    uint32 *dos_error,
 180                    ENUM_SRVC_STATUS **svcs, uint32 *num_svcs)
 181 {
 182         prs_struct rbuf;
 183         prs_struct buf;
 184         SVC_Q_ENUM_SVCS_STATUS q_o;
 185         BOOL valid_pol = False;
 186
 187         struct cli_connection *con = NULL;
 188
 189         if (!cli_connection_get(hnd, &con))
 190         {
 191                 return False;
 192         }
 193
 194         if (hnd == NULL || buf_size == NULL || dos_error == NULL
 195             || num_svcs == NULL)
 196         {
 197                 return False;
 198         }
 199
 200         prs_init(&buf , 0, 4, False);
 201         prs_init(&rbuf, 0, 4, True );
 202
 203         /* create and send a MSRPC command with api SVC_ENUM_SVCS_STATUS */
 204
 205         DEBUG(4, ("SVC Enum Services Status\n"));
 206
 207         make_svc_q_enum_svcs_status(&q_o, hnd,
 208                                     services_type, services_state,
 209                                     *buf_size, *resume_hnd);
 210
 211         /* turn parameters into data stream */
 212         if (svc_io_q_enum_svcs_status("", &q_o, &buf, 0) &&
 213             rpc_con_pipe_req(con, SVC_ENUM_SVCS_STATUS, &buf, &rbuf))
 214         {
 215                 SVC_R_ENUM_SVCS_STATUS r_o;
 216                 BOOL p;
 217
 218                 ZERO_STRUCT(r_o);
 219
 220                 svc_io_r_enum_svcs_status("", &r_o, &rbuf, 0);
 221                 p = rbuf.offset != 0;
 222
 223                 if (p && r_o.dos_status != 0)
 224                 {
 225                         fstring errmsg;
 226
 227                         if (r_o.dos_status != ERRmoredata)
 228                         {
 229                                 smb_safe_err_msg(ERRDOS, r_o.dos_status,
 230                                                  errmsg, sizeof(errmsg));
 231                                 /* report error code */
 232                                 DEBUG(1, ("SVC_ENUM_SVCS_STATUS: %s\n",
 233                                           errmsg));
 234                         }
 235                         p = r_o.dos_status == ERRmoredata;
 236                 }
 237
 238                 if (p)
 239                 {
 240                         (*svcs) = r_o.svcs;
 241                         (*num_svcs) = r_o.num_svcs;
 242                         (*resume_hnd) = get_enum_hnd(&r_o.resume_hnd);
 243                         (*buf_size) = r_o.more_buf_size;
 244                         (*dos_error) = r_o.dos_status;
 245                         valid_pol = True;
 246                 }
 247         }
 248
 249         prs_free_data(&rbuf);
 250         prs_free_data(&buf );
 251
 252         return valid_pol;
 253 }
 254
 255
 256 /****************************************************************************
 257 do a SVC Stop Service
 258 ****************************************************************************/
 259 BOOL svc_stop_service(POLICY_HND *hnd, uint32 unknown)
 260 {
 261         prs_struct rbuf;
 262         prs_struct buf;
 263         SVC_Q_STOP_SERVICE q_c;
 264         BOOL valid_cfg = False;
 265
 266         struct cli_connection *con = NULL;
 267
 268         if (!cli_connection_get(hnd, &con))
 269         {
 270                 return False;
 271         }
 272
 273         if (hnd == NULL)
 274                 return False;
 275
 276         /* create and send a MSRPC command with api SVC_STOP_SERVICE */
 277
 278         prs_init(&buf , 0, 4, False);
 279         prs_init(&rbuf, 0, 4, True );
 280
 281         DEBUG(4, ("SVC Stop Service\n"));
 282
 283         /* store the parameters */
 284         make_svc_q_stop_service(&q_c, hnd, unknown);
 285
 286         /* turn parameters into data stream */
 287         if (svc_io_q_stop_service("", &q_c, &buf, 0) &&
 288             rpc_con_pipe_req(con, SVC_STOP_SERVICE, &buf, &rbuf))
 289         {
 290                 SVC_R_STOP_SERVICE r_c;
 291                 BOOL p;
 292
 293                 ZERO_STRUCT(r_c);
 294
 295                 svc_io_r_stop_service("", &r_c, &rbuf, 0);
 296                 p = rbuf.offset != 0;
 297
 298                 if (p && r_c.status != 0)
 299                 {
 300                         /* report error code */
 301                         DEBUG(1, ("SVC_START_SERVICE: %s\n",
 302                                   get_nt_error_msg(r_c.status)));
 303                         p = False;
 304                 }
 305
 306                 if (p)
 307                 {
 308                         valid_cfg = True;
 309                 }
 310         }
 311
 312         prs_free_data(&rbuf);
 313         prs_free_data(&buf );
 314
 315         return valid_cfg;
 316 }
 317
 318
 319 /****************************************************************************
 320 do a SVC Start Service
 321 ****************************************************************************/
 322 BOOL svc_start_service(POLICY_HND *hnd, uint32 argc, char **argv)
 323 {
 324         prs_struct rbuf;
 325         prs_struct buf;
 326         SVC_Q_START_SERVICE q_c;
 327         BOOL valid_cfg = False;
 328
 329         struct cli_connection *con = NULL;
 330
 331         if (!cli_connection_get(hnd, &con))
 332         {
 333                 return False;
 334         }
 335
 336         if (hnd == NULL)
 337                 return False;
 338
 339         /* create and send a MSRPC command with api SVC_START_SERVICE */
 340
 341         prs_init(&buf , 0, 4, False);
 342         prs_init(&rbuf, 0, 4, True );
 343
 344         DEBUG(4, ("SVC Start Service\n"));
 345
 346         /* store the parameters */
 347         make_svc_q_start_service(&q_c, hnd, argc, argv);
 348
 349         /* turn parameters into data stream */
 350         if (svc_io_q_start_service("", &q_c, &buf, 0) &&
 351             rpc_con_pipe_req(con, SVC_START_SERVICE, &buf, &rbuf))
 352         {
 353                 SVC_R_START_SERVICE r_c;
 354                 BOOL p;
 355
 356                 ZERO_STRUCT(r_c);
 357
 358                 svc_io_r_start_service("", &r_c, &rbuf, 0);
 359                 p = rbuf.offset != 0;
 360
 361                 if (p && r_c.status != 0)
 362                 {
 363                         /* report error code */
 364                         DEBUG(1, ("SVC_START_SERVICE: %s\n",
 365                                   get_nt_error_msg(r_c.status)));
 366                         p = False;
 367                 }
 368
 369                 if (p)
 370                 {
 371                         valid_cfg = True;
 372                 }
 373         }
 374
 375         prs_free_data(&rbuf);
 376         prs_free_data(&buf );
 377
 378         return valid_cfg;
 379 }
 380
 381
 382 /****************************************************************************
 383 do a SVC Query Service Config
 384 ****************************************************************************/
 385 BOOL svc_query_svc_cfg(POLICY_HND *hnd,
 386                        QUERY_SERVICE_CONFIG *cfg, uint32 *buf_size)
 387 {
 388         prs_struct rbuf;
 389         prs_struct buf;
 390         SVC_Q_QUERY_SVC_CONFIG q_c;
 391         BOOL valid_cfg = False;
 392
 393         struct cli_connection *con = NULL;
 394
 395         if (!cli_connection_get(hnd, &con))
 396         {
 397                 return False;
 398         }
 399
 400         if (hnd == NULL || buf_size == NULL)
 401                 return False;
 402
 403         /* create and send a MSRPC command with api SVC_QUERY_SVC_CONFIG */
 404
 405         prs_init(&buf , 0, 4, False);
 406         prs_init(&rbuf, 0, 4, True );
 407
 408         DEBUG(4, ("SVC Query Service Config\n"));
 409
 410         /* store the parameters */
 411         make_svc_q_query_svc_config(&q_c, hnd, *buf_size);
 412
 413         /* turn parameters into data stream */
 414         if (svc_io_q_query_svc_config("", &q_c, &buf, 0) &&
 415             rpc_con_pipe_req(con, SVC_QUERY_SVC_CONFIG, &buf, &rbuf))
 416         {
 417                 SVC_R_QUERY_SVC_CONFIG r_c;
 418                 BOOL p;
 419
 420                 ZERO_STRUCT(r_c);
 421                 ZERO_STRUCTP(cfg);
 422
 423                 r_c.cfg = cfg;
 424
 425                 svc_io_r_query_svc_config("", &r_c, &rbuf, 0);
 426                 p = rbuf.offset != 0;
 427
 428                 if (p && r_c.status != 0)
 429                 {
 430                         /* report error code */
 431                         DEBUG(1, ("SVC_QUERY_SVC_CONFIG: %s\n",
 432                                   get_nt_error_msg(r_c.status)));
 433                         p = False;
 434                 }
 435
 436                 if (p)
 437                 {
 438                         valid_cfg = r_c.buf_size != 0;
 439                 }
 440         }
 441
 442         prs_free_data(&rbuf);
 443         prs_free_data(&buf );
 444
 445         return valid_cfg;
 446 }
 447
 448
 449 /****************************************************************************
 450 do a SVC Close
 451 ****************************************************************************/
 452 BOOL svc_close(POLICY_HND *hnd)
 453 {
 454         prs_struct rbuf;
 455         prs_struct buf;
 456         SVC_Q_CLOSE q_c;
 457         BOOL valid_close = False;
 458
 459         struct cli_connection *con = NULL;
 460
 461         if (!cli_connection_get(hnd, &con))
 462         {
 463                 return False;
 464         }
 465
 466         if (hnd == NULL)
 467                 return False;
 468
 469         /* create and send a MSRPC command with api SVC_CLOSE */
 470
 471         prs_init(&buf , 0, 4, False);
 472         prs_init(&rbuf, 0, 4, True );
 473
 474         DEBUG(4, ("SVC Close\n"));
 475
 476         /* store the parameters */
 477         make_svc_q_close(&q_c, hnd);
 478
 479         /* turn parameters into data stream */
 480         if (svc_io_q_close("", &q_c, &buf, 0) &&
 481             rpc_con_pipe_req(con, SVC_CLOSE, &buf, &rbuf))
 482         {
 483                 SVC_R_CLOSE r_c;
 484                 BOOL p;
 485
 486                 ZERO_STRUCT(r_c);
 487
 488                 svc_io_r_close("", &r_c, &rbuf, 0);
 489                 p = rbuf.offset != 0;
 490
 491                 if (p && r_c.status != 0)
 492                 {
 493                         /* report error code */
 494                         DEBUG(1, ("SVC_CLOSE: %s\n",
 495                                   get_nt_error_msg(r_c.status)));
 496                         p = False;
 497                 }
 498
 499                 if (p)
 500                 {
 501                         valid_close = True;
 502                 }
 503         }
 504
 505         close_policy_hnd(get_global_hnd_cache(), hnd);
 506
 507         prs_free_data(&rbuf);
 508         prs_free_data(&buf );
 509
 510         return valid_close;
 511 }
 512
 513 /****************************************************************************
 514 do a SVC Change Service Config
 515 ****************************************************************************/
 516 BOOL svc_change_svc_cfg(POLICY_HND *hnd,
 517                         uint32 service_type, uint32 start_type,
 518                         uint32 unknown_0, uint32 error_control,
 519                         char *bin_path_name, char *load_order_grp,
 520                         uint32 tag_id,
 521                         char *dependencies, char *service_start_name,
 522                         char *password, char *disp_name)
 523 {
 524         prs_struct rbuf;
 525         prs_struct buf;
 526         SVC_Q_CHANGE_SVC_CONFIG q_c;
 527         BOOL valid_cfg = False;
 528
 529         struct cli_connection *con = NULL;
 530
 531         if (!cli_connection_get(hnd, &con))
 532         {
 533                 return False;
 534         }
 535
 536         if (hnd == NULL)
 537                 return False;
 538
 539         /* create and send a MSRPC command with api SVC_CHANGE_SVC_CONFIG */
 540
 541         prs_init(&buf , 0, 4, False);
 542         prs_init(&rbuf, 0, 4, True );
 543
 544         DEBUG(4, ("SVC Change Service Config\n"));
 545
 546         /* store the parameters */
 547         make_svc_q_change_svc_config(&q_c, hnd,
 548                                 service_type, start_type,
 549                                 unknown_0, error_control,
 550                                 bin_path_name, load_order_grp,
 551                                 tag_id,
 552                                 dependencies, service_start_name,
 553                                 password, disp_name);
 554
 555         /* turn parameters into data stream */
 556         if (svc_io_q_change_svc_config("", &q_c, &buf, 0) &&
 557             rpc_con_pipe_req(con, SVC_CHANGE_SVC_CONFIG, &buf, &rbuf))
 558         {
 559                 SVC_R_CHANGE_SVC_CONFIG r_c;
 560                 BOOL p;
 561
 562                 ZERO_STRUCT(r_c);
 563
 564                 svc_io_r_change_svc_config("", &r_c, &rbuf, 0);
 565                 p = rbuf.offset != 0;
 566
 567                 if (p && r_c.status != 0)
 568                 {
 569                         /* report error code */
 570                         DEBUG(1, ("SVC_CHANGE_SVC_CONFIG: %s\n",
 571                                   get_nt_error_msg(r_c.status)));
 572                         p = False;
 573                 }
 574
 575                 if (p)
 576                 {
 577                         valid_cfg = True;
 578                 }
 579         }
 580
 581         prs_free_data(&rbuf);
 582         prs_free_data(&buf );
 583
 584         return valid_cfg;
 585 }
 586
 587 /****************************************************************************
 588 do a SVC unknown 3
 589 ****************************************************************************/
 590 BOOL svc_unknown_3(const POLICY_HND *scman_hnd, POLICY_HND *hnd)
 591 {
 592         prs_struct rbuf;
 593         prs_struct buf;
 594         SVC_Q_UNKNOWN_3 q_c;
 595         BOOL valid_req = False;
 596
 597         struct cli_connection *con = NULL;
 598
 599         if (scman_hnd == NULL)
 600                 return False;
 601
 602         if (!cli_connection_get(scman_hnd, &con))
 603         {
 604                 return False;
 605         }
 606
 607         prs_init(&buf , 0, 4, False);
 608         prs_init(&rbuf, 0, 4, True );
 609
 610         DEBUG(4, ("SVC Unknown 3\n"));
 611
 612         /* store the parameters */
 613         q_c.scman_hnd = *scman_hnd;
 614
 615         /* turn parameters into data stream */
 616         if (svc_io_q_unknown_3("", &q_c, &buf, 0) &&
 617             rpc_con_pipe_req(con, SVC_UNKNOWN_3, &buf, &rbuf))
 618         {
 619                 SVC_R_UNKNOWN_3 r_o;
 620                 BOOL p;
 621
 622                 ZERO_STRUCT(r_o);
 623
 624                 p = svc_io_r_unknown_3("", &r_o, &rbuf, 0);
 625
 626                 if (p)
 627                         p = (rbuf.offset != 0);
 628
 629                 if (p && r_o.status != 0)
 630                 {
 631                         /* report error code */
 632                         DEBUG(1, ("SVC_OPEN_SC_MAN: %s\n",
 633                                   get_nt_error_msg(r_o.status)));
 634                         p = False;
 635                 }
 636
 637                 if (p)
 638                 {
 639                         /* ok, at last: we're happy. return the policy handle */
 640                         *hnd = r_o.hnd;
 641                         valid_req =
 642                                 register_policy_hnd(get_global_hnd_cache(),
 643                                                     cli_con_sec_ctx(con),
 644                                                     hnd, 0x0)
 645                                 && set_policy_con(get_global_hnd_cache(), hnd,
 646                                                   con, cli_connection_unlink);
 647                         if (valid_req)
 648                         {
 649                                 policy_hnd_set_name(get_global_hnd_cache(),
 650                                                     hnd, "unknown 3 handle");
 651                         }
 652                 }
 653         }
 654
 655         prs_free_data(&rbuf);
 656         prs_free_data(&buf );
 657
 658         return valid_req;
 659 }
 660
 661 /****************************************************************************
 662 do a SVC Stop Service
 663 ****************************************************************************/
 664 uint32 svc_get_svc_sec(const POLICY_HND *hnd, uint32 sec_info,
 665                        /* [in,out] */ uint32 *buf_size,
 666                        SEC_DESC **sec_desc)
 667 {
 668         prs_struct rbuf;
 669         prs_struct buf;
 670         SVC_Q_GET_SVC_SEC q;
 671         BOOL status = NT_STATUS_INVALID_PARAMETER;
 672
 673         if (hnd == NULL || buf_size == NULL)
 674                 return NT_STATUS_INVALID_PARAMETER;
 675
 676         /* create and send a MSRPC command with api SVC_STOP_SERVICE */
 677
 678         prs_init(&buf , 0, 4, False);
 679         prs_init(&rbuf, 0, 4, True );
 680
 681         DEBUG(4, ("SVC Stop Service\n"));
 682
 683         /* store the parameters */
 684         q.hnd = *hnd;
 685         q.sec_info = sec_info;
 686         q.buf_size = *buf_size;
 687
 688         /* turn parameters into data stream */
 689         if (svc_io_q_get_svc_sec("", &q, &buf, 0)
 690             && rpc_hnd_pipe_req(hnd, SVC_GET_SVC_SEC, &buf, &rbuf))
 691         {
 692                 SVC_R_GET_SVC_SEC r;
 693                 ZERO_STRUCT(r);
 694
 695                 if(svc_io_r_get_svc_sec("", &r, &rbuf, 0)
 696                    && rbuf.offset != 0)
 697                 {
 698                         status = r.status;
 699                         if(status != NT_STATUS_NOPROBLEMO)
 700                                 DEBUG(1, ("SVC_GET_SVC_SEC: %s\n",
 701                                           get_nt_error_msg(status)));
 702                         *buf_size = r.buf_size;
 703                         if(sec_desc)
 704                         {
 705                                 *sec_desc = r.sd;
 706                         }
 707                         else
 708                         {
 709                                 if(r.sd)
 710                                 {
 711                                         free_sec_desc(r.sd);
 712                                         free(r.sd);
 713                                 }
 714                         }
 715                 }
 716                 else
 717                 {
 718                         if(sec_desc)
 719                                 *sec_desc = NULL;
 720                 }
 721         }
 722
 723         prs_free_data(&rbuf);
 724         prs_free_data(&buf );
 725
 726         return status;
 727 }