libopkg/libopkg.c

   1 /* opkglib.c - the opkg package management system
   2
   3    Florina Boor
   4
   5    Copyright (C) 2003 kernel concepts
   6
   7    This program is free software; you can redistribute it and/or
   8    modify it under the terms of the GNU General Public License as
   9    published by the Free Software Foundation; either version 2, or (at
  10    your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful, but
  13    WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15    General Public License for more details.
  16 */
  17
  18 #include "includes.h"
  19 #include "libopkg.h"
  20
  21 #include "args.h"
  22 #include "opkg_conf.h"
  23 #include "opkg_cmd.h"
  24 #include "file_util.h"
  25
  26 #include "opkg_message.h"
  27 #include "opkg_error.h"
  28
  29 opkg_status_callback opkg_cb_status = NULL;
  30 opkg_list_callback opkg_cb_list = NULL;
  31
  32
  33 int
  34 opkg_init (opkg_message_callback mcall,
  35            opkg_response_callback rcall,
  36            args_t * args)
  37 {
  38         opkg_cb_message = mcall;
  39         opkg_cb_response = rcall;
  40
  41         args_init (args);
  42
  43         return 0;
  44 }
  45
  46
  47 int
  48 opkg_deinit (args_t * args)
  49 {
  50         args_deinit (args);
  51         opkg_cb_message = NULL;
  52         opkg_cb_response = NULL;
  53
  54         /* place other cleanup stuff here */
  55
  56         return 0;
  57 }
  58
  59
  60 int
  61 opkg_packages_list(args_t *args,
  62                    const char *packages,
  63                    opkg_list_callback cblist,
  64                    void *userdata)
  65 {
  66         opkg_cmd_t *cmd;
  67         opkg_conf_t opkg_conf;
  68         int err;
  69
  70         err = opkg_conf_init (&opkg_conf, args);
  71         if (err)
  72         {
  73                 return err;
  74         }
  75
  76         opkg_cb_list = cblist;
  77         /* we need to do this because of static declarations,
  78          * maybe a good idea to change */
  79         cmd = opkg_cmd_find ("list");
  80         if (packages)
  81                 err = opkg_cmd_exec (cmd, &opkg_conf, 1, &packages, userdata);
  82         else
  83                 err = opkg_cmd_exec (cmd, &opkg_conf, 0, NULL, userdata);
  84         opkg_cb_list = NULL;
  85         opkg_conf_deinit (&opkg_conf);
  86         return (err);
  87 }
  88
  89
  90 int
  91 opkg_packages_status(args_t *args,
  92                      const char *packages,
  93                      opkg_status_callback cbstatus,
  94                      void *userdata)
  95 {
  96         opkg_cmd_t *cmd;
  97         opkg_conf_t opkg_conf;
  98         int err;
  99
 100         err = opkg_conf_init (&opkg_conf, args);
 101         if (err)
 102         {
 103                 return err;
 104         }
 105
 106         opkg_cb_status = cbstatus;
 107
 108         /* we need to do this because of static declarations,
 109          * maybe a good idea to change */
 110         cmd = opkg_cmd_find ("status");
 111         if (packages)
 112                 err = opkg_cmd_exec (cmd, &opkg_conf, 1, &packages, userdata);
 113         else
 114                 err = opkg_cmd_exec (cmd, &opkg_conf, 0, NULL, userdata);
 115
 116         opkg_cb_status = NULL;
 117         opkg_conf_deinit (&opkg_conf);
 118         return (err);
 119 }
 120
 121
 122 int
 123 opkg_packages_info(args_t *args,
 124                    const char *packages,
 125                    opkg_status_callback cbstatus,
 126                    void *userdata)
 127 {
 128         opkg_cmd_t *cmd;
 129         opkg_conf_t opkg_conf;
 130         int err;
 131
 132         err = opkg_conf_init (&opkg_conf, args);
 133         if (err)
 134         {
 135                 return err;
 136         }
 137
 138         opkg_cb_status = cbstatus;
 139
 140         /* we need to do this because of static declarations,
 141          * maybe a good idea to change */
 142         cmd = opkg_cmd_find ("info");
 143         if (packages)
 144                 err = opkg_cmd_exec (cmd, &opkg_conf, 1, &packages, userdata);
 145         else
 146                 err = opkg_cmd_exec (cmd, &opkg_conf, 0, NULL, userdata);
 147
 148         opkg_cb_status = NULL;
 149         opkg_conf_deinit (&opkg_conf);
 150         return (err);
 151 }
 152
 153
 154 int
 155 opkg_packages_install (args_t * args, const char *name)
 156 {
 157         opkg_cmd_t *cmd;
 158         opkg_conf_t opkg_conf;
 159         int err;
 160
 161         /* this error should be handled in application */
 162         if (!name || !strlen (name))
 163                 return (-1);
 164
 165         err = opkg_conf_init (&opkg_conf, args);
 166         if (err)
 167         {
 168                 return err;
 169         }
 170
 171         /* we need to do this because of static declarations,
 172          * maybe a good idea to change */
 173         cmd = opkg_cmd_find ("install");
 174         err = opkg_cmd_exec (cmd, &opkg_conf, 1, &name, NULL);
 175
 176         opkg_conf_deinit(&opkg_conf);
 177         return (err);
 178 }
 179
 180
 181 int
 182 opkg_packages_remove(args_t *args, const char *name, int purge)
 183 {
 184         opkg_cmd_t *cmd;
 185         opkg_conf_t opkg_conf;
 186         int err;
 187
 188         /* this error should be handled in application */
 189         if (!name || !strlen (name))
 190                 return (-1);
 191
 192         err = opkg_conf_init (&opkg_conf, args);
 193         if (err)
 194         {
 195                 return err;
 196         }
 197
 198         /* we need to do this because of static declarations,
 199          * maybe a good idea to change */
 200         if (purge)
 201                 cmd = opkg_cmd_find ("purge");
 202         else
 203                 cmd = opkg_cmd_find ("remove");
 204
 205         err = opkg_cmd_exec (cmd, &opkg_conf, 1, &name, NULL);
 206
 207         opkg_conf_deinit(&opkg_conf);
 208         return (err);
 209 }
 210
 211
 212 int
 213 opkg_lists_update(args_t *args)
 214 {
 215         opkg_cmd_t *cmd;
 216         opkg_conf_t opkg_conf;
 217         int err;
 218
 219         err = opkg_conf_init (&opkg_conf, args);
 220         if (err)
 221         {
 222                 return err;
 223         }
 224
 225         /* we need to do this because of static declarations,
 226          * maybe a good idea to change */
 227         cmd = opkg_cmd_find ("update");
 228
 229         err = opkg_cmd_exec (cmd, &opkg_conf, 0, NULL, NULL);
 230
 231         opkg_conf_deinit(&opkg_conf);
 232         return (err);
 233 }
 234
 235
 236 int
 237 opkg_packages_upgrade(args_t *args)
 238 {
 239         opkg_cmd_t *cmd;
 240         opkg_conf_t opkg_conf;
 241         int err;
 242
 243         err = opkg_conf_init (&opkg_conf, args);
 244         if (err)
 245         {
 246                 return err;
 247         }
 248
 249         /* we need to do this because of static declarations,
 250          * maybe a good idea to change */
 251         cmd = opkg_cmd_find ("upgrade");
 252
 253         err = opkg_cmd_exec (cmd, &opkg_conf, 0, NULL, NULL);
 254
 255         opkg_conf_deinit(&opkg_conf);
 256         return (err);
 257 }
 258
 259
 260 int
 261 opkg_packages_download (args_t * args, const char *name)
 262 {
 263         opkg_cmd_t *cmd;
 264         opkg_conf_t opkg_conf;
 265         int err;
 266
 267         /* this error should be handled in application */
 268         if (!name || !strlen (name))
 269                 return (-1);
 270
 271         err = opkg_conf_init (&opkg_conf, args);
 272         if (err)
 273         {
 274                 opkg_print_error_list (&opkg_conf);
 275                 return err;
 276         }
 277
 278         /* we need to do this because of static declarations,
 279          * maybe a good idea to change */
 280         cmd = opkg_cmd_find ("download");
 281         err = opkg_cmd_exec (cmd, &opkg_conf, 1, &name, NULL);
 282
 283         opkg_conf_deinit(&opkg_conf);
 284         return (err);
 285 }
 286
 287
 288 int
 289 opkg_package_files(args_t *args,
 290                    const char *name,
 291                    opkg_list_callback cblist,
 292                    void *userdata)
 293 {
 294         opkg_cmd_t *cmd;
 295         opkg_conf_t opkg_conf;
 296         int err;
 297
 298         /* this error should be handled in application */
 299         if (!name || !strlen (name))
 300                 return (-1);
 301
 302         err = opkg_conf_init (&opkg_conf, args);
 303         if (err)
 304         {
 305                 return err;
 306         }
 307
 308         opkg_cb_list = cblist;
 309
 310         /* we need to do this because of static declarations,
 311          * maybe a good idea to change */
 312         cmd = opkg_cmd_find ("files");
 313
 314         err = opkg_cmd_exec (cmd, &opkg_conf, 1, &name, userdata);
 315
 316         opkg_cb_list = NULL;
 317         opkg_conf_deinit(&opkg_conf);
 318         return (err);
 319 }
 320
 321
 322 int
 323 opkg_file_search(args_t *args,
 324                 const char *file,
 325                                 opkg_list_callback cblist,
 326                 void *userdata)
 327 {
 328         opkg_cmd_t *cmd;
 329         opkg_conf_t opkg_conf;
 330         int err;
 331
 332         /* this error should be handled in application */
 333         if (!file || !strlen (file))
 334                 return (-1);
 335
 336         err = opkg_conf_init (&opkg_conf, args);
 337         if (err)
 338         {
 339                 return err;
 340         }
 341
 342         opkg_cb_list = cblist;
 343
 344         /* we need to do this because of static declarations,
 345          * maybe a good idea to change */
 346         cmd = opkg_cmd_find ("search");
 347         err = opkg_cmd_exec (cmd, &opkg_conf, 1, &file, userdata);
 348
 349         opkg_cb_list = NULL;
 350         opkg_conf_deinit(&opkg_conf);
 351         return(err);
 352 }
 353
 354
 355 int
 356 opkg_file_what(args_t *args, const char *file, const char* command)
 357 {
 358         opkg_cmd_t *cmd;
 359         opkg_conf_t opkg_conf;
 360         int err;
 361
 362         /* this error should be handled in application */
 363         if (!file || !strlen (file))
 364                 return (-1);
 365
 366         err = opkg_conf_init (&opkg_conf, args);
 367         if (err)
 368         {
 369                 return err;
 370         }
 371
 372         /* we need to do this because of static declarations,
 373          * maybe a good idea to change */
 374         cmd = opkg_cmd_find (command);
 375         err = opkg_cmd_exec (cmd, &opkg_conf, 1, &file, NULL);
 376
 377         opkg_conf_deinit(&opkg_conf);
 378         return(err);
 379 }
 380
 381 #define opkg_package_whatdepends(args,file) opkg_file_what(args,file,"whatdepends")
 382 #define opkg_package_whatrecommends(args, file) opkg_file_what(args,file,"whatrecommends")
 383 #define opkg_package_whatprovides(args, file) opkg_file_what(args,file,"whatprovides")
 384 #define opkg_package_whatconflicts(args, file) opkg_file_what(args,file,"whatconflicts")
 385 #define opkg_package_whatreplaces(args, file) opkg_file_what(args,file,"whatreplaces")
 386
 387
 388 int default_opkg_message_callback(opkg_conf_t *conf, message_level_t level,
 389                                   char *msg)
 390 {
 391      if (conf && (conf->verbosity < level)) {
 392           return 0;
 393      } else {
 394           if ( level == OPKG_ERROR ){
 395              push_error_list(&error_list, msg);
 396           } else
 397              printf(msg);
 398      }
 399      return 0;
 400 }
 401
 402 int default_opkg_list_callback(char *name, char *desc, char *version,
 403                                pkg_state_status_t status, void *userdata)
 404 {
 405      if (desc)
 406           printf("%s - %s - %s\n", name, version, desc);
 407      else
 408           printf("%s - %s\n", name, version);
 409      return 0;
 410 }
 411
 412 int default_opkg_files_callback(char *name, char *desc, char *version,
 413                    pkg_state_status_t status, void *userdata)
 414 {
 415      if (desc)
 416           printf("%s\n", desc);
 417      return 0;
 418 }
 419
 420 int default_opkg_status_callback(char *name, int istatus, char *desc,
 421                                  void *userdata)
 422 {
 423      printf("%s\n", desc);
 424      return 0;
 425 }
 426
 427 char* default_opkg_response_callback(char *question)
 428 {
 429      char *response = NULL;
 430      printf(question);
 431      fflush(stdout);
 432      do {
 433           response = (char *)file_read_line_alloc(stdin);
 434      } while (response == NULL);
 435      return response;
 436 }
 437
 438 /* This is used for backward compatibility */
 439 int
 440 opkg_op (int argc, char *argv[])
 441 {
 442         int err, optind;
 443         args_t args;
 444         char *cmd_name;
 445         opkg_cmd_t *cmd;
 446         opkg_conf_t opkg_conf;
 447
 448         args_init (&args);
 449
 450         optind = args_parse (&args, argc, argv);
 451         if (optind == argc || optind < 0)
 452         {
 453                 args_usage ("opkg must have one sub-command argument");
 454         }
 455
 456         cmd_name = argv[optind++];
 457 /* Pigi: added a flag to disable the checking of structures if the command does not need to
 458          read anything from there.
 459 */
 460         if ( !strcmp(cmd_name,"print-architecture") ||
 461              !strcmp(cmd_name,"print_architecture") ||
 462              !strcmp(cmd_name,"print-installation-architecture") ||
 463              !strcmp(cmd_name,"print_installation_architecture") )
 464            args.nocheckfordirorfile = 1;
 465
 466 /* Pigi: added a flag to disable the reading of feed files  if the command does not need to
 467          read anything from there.
 468 */
 469         if ( !strcmp(cmd_name,"flag") ||
 470              !strcmp(cmd_name,"configure") ||
 471              !strcmp(cmd_name,"remove") ||
 472              !strcmp(cmd_name,"files") ||
 473              !strcmp(cmd_name,"search") ||
 474              !strcmp(cmd_name,"compare_versions") ||
 475              !strcmp(cmd_name,"compare-versions") ||
 476              !strcmp(cmd_name,"list_installed") ||
 477              !strcmp(cmd_name,"list-installed") ||
 478              !strcmp(cmd_name,"status") )
 479            args.noreadfeedsfile = 1;
 480
 481         opkg_cb_message = default_opkg_message_callback;
 482         opkg_cb_response = default_opkg_response_callback;
 483         opkg_cb_status = default_opkg_status_callback;
 484
 485
 486         err = opkg_conf_init (&opkg_conf, &args);
 487         if (err)
 488         {
 489                 opkg_print_error_list (&opkg_conf);
 490                 return err;
 491         }
 492
 493         args_deinit (&args);
 494
 495         if ( strcmp(cmd_name, "files")==0)
 496              opkg_cb_list = default_opkg_files_callback;
 497         else
 498              opkg_cb_list = default_opkg_list_callback;
 499
 500         cmd = opkg_cmd_find (cmd_name);
 501         if (cmd == NULL)
 502         {
 503                 fprintf (stderr, "%s: unknown sub-command %s\n", argv[0],
 504                          cmd_name);
 505                 args_usage (NULL);
 506         }
 507
 508         if (cmd->requires_args && optind == argc)
 509         {
 510                 fprintf (stderr,
 511                          "%s: the ``%s'' command requires at least one argument\n",
 512                          __FUNCTION__, cmd_name);
 513                 args_usage (NULL);
 514         }
 515
 516         err = opkg_cmd_exec (cmd, &opkg_conf, argc - optind, (const char **) (argv + optind), NULL);
 517
 518         opkg_conf_deinit (&opkg_conf);
 519
 520         return err;
 521 }