Ignore:
Timestamp:
06/04/08 17:34:52 (5 years ago)
Author:
thomas
Message:

opkg: remove unused code

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/target/opkg/libopkg/libopkg.c

    r4473 r4475  
    2929opkg_status_callback opkg_cb_status = NULL; 
    3030opkg_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  
    38731 
    38832int default_opkg_message_callback(opkg_conf_t *conf, message_level_t level,  
Note: See TracChangeset for help on using the changeset viewer.