Branch data     Line data    Source code

       1                 :            : /*-
       2                 :            :  * Copyright (c) 2011-2013 Baptiste Daroussin <bapt@FreeBSD.org>
       3                 :            :  * Copyright (c) 2011-2012 Julien Laffaye <jlaffaye@FreeBSD.org>
       4                 :            :  * Copyright (c) 2013 Matthew Seaman <matthew@FreeBSD.org>
       5                 :            :  * All rights reserved.
       6                 :            :  * 
       7                 :            :  * Redistribution and use in source and binary forms, with or without
       8                 :            :  * modification, are permitted provided that the following conditions
       9                 :            :  * are met:
      10                 :            :  * 1. Redistributions of source code must retain the above copyright
      11                 :            :  *    notice, this list of conditions and the following disclaimer
      12                 :            :  *    in this position and unchanged.
      13                 :            :  * 2. Redistributions in binary form must reproduce the above copyright
      14                 :            :  *    notice, this list of conditions and the following disclaimer in the
      15                 :            :  *    documentation and/or other materials provided with the distribution.
      16                 :            :  * 
      17                 :            :  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
      18                 :            :  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
      19                 :            :  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
      20                 :            :  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
      21                 :            :  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
      22                 :            :  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
      23                 :            :  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
      24                 :            :  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      25                 :            :  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
      26                 :            :  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
      27                 :            :  */
      28                 :            : 
      29                 :            : #include <assert.h>
      30                 :            : 
      31                 :            : #include "pkg.h"
      32                 :            : #include "private/event.h"
      33                 :            : #include "private/pkg.h"
      34                 :            : 
      35                 :            : /*
      36                 :            :  * Dep
      37                 :            :  */
      38                 :            : void
      39                 :       1631 : pkg_dep_free(struct pkg_dep *d)
      40                 :            : {
      41         [ -  + ]:       1631 :         if (d == NULL)
      42                 :          0 :                 return;
      43                 :            : 
      44                 :       1631 :         free(d->origin);
      45                 :       1631 :         free(d->name);
      46                 :       1631 :         free(d->version);
      47                 :       1631 :         free(d->uid);
      48                 :       1631 :         free(d);
      49                 :       1631 : }
      50                 :            : 
      51                 :            : const char *
      52                 :         65 : pkg_dep_get(struct pkg_dep const * const d, const pkg_dep_attr attr)
      53                 :            : {
      54         [ +  - ]:         65 :         assert(d != NULL);
      55                 :            : 
      56   [ -  +  -  - ]:         65 :         switch (attr) {
      57                 :            :         case PKG_DEP_NAME:
      58                 :         65 :                 return (d->name);
      59                 :            :                 break;
      60                 :            :         case PKG_DEP_ORIGIN:
      61                 :          0 :                 return (d->origin);
      62                 :            :                 break;
      63                 :            :         case PKG_DEP_VERSION:
      64                 :          0 :                 return (d->version);
      65                 :            :                 break;
      66                 :            :         default:
      67                 :          0 :                 return (NULL);
      68                 :            :                 break;
      69                 :            :         }
      70                 :         65 : }
      71                 :            : 
      72                 :            : bool
      73                 :          0 : pkg_dep_is_locked(struct pkg_dep const * const d)
      74                 :            : {
      75         [ #  # ]:          0 :         assert(d != NULL);
      76                 :            : 
      77                 :          0 :         return d->locked;
      78                 :            : }
      79                 :            : 
      80                 :            : /*
      81                 :            :  * File
      82                 :            :  */
      83                 :            : void
      84                 :       3135 : pkg_file_free(struct pkg_file *file)
      85                 :            : {
      86                 :            : 
      87                 :       3135 :         free(file->sum);
      88                 :       3135 :         free(file);
      89                 :       3135 : }
      90                 :            : 
      91                 :            : /*
      92                 :            :  * Script
      93                 :            :  */
      94                 :            : 
      95                 :            : const char *
      96                 :      41391 : pkg_script_get(struct pkg const * const p, pkg_script i)
      97                 :            : {
      98         [ +  + ]:      41391 :         if (p->scripts[i] == NULL)
      99                 :      40053 :                 return (NULL);
     100                 :            : 
     101                 :       1338 :         fflush(p->scripts[i]->fp);
     102                 :       1338 :         return (p->scripts[i]->buf);
     103                 :      41391 : }
     104                 :            : 
     105                 :            : /*
     106                 :            :  * Option
     107                 :            :  */
     108                 :            : void
     109                 :        808 : pkg_option_free(struct pkg_option *option)
     110                 :            : {
     111         [ -  + ]:        808 :         if (option == NULL)
     112                 :          0 :                 return;
     113                 :            : 
     114                 :        808 :         free(option->key);
     115                 :        808 :         free(option->value);
     116                 :        808 :         free(option->default_value);
     117                 :        808 :         free(option->description);
     118                 :        808 :         free(option);
     119                 :        808 : }
     120                 :            : 
     121                 :            : /*
     122                 :            :  * Conflicts
     123                 :            :  */
     124                 :            : void
     125                 :          0 : pkg_conflict_free(struct pkg_conflict *c)
     126                 :            : {
     127         [ #  # ]:          0 :         if (c == NULL)
     128                 :          0 :                 return;
     129                 :            : 
     130                 :          0 :         free(c->uid);
     131                 :          0 :         free(c->digest);
     132                 :          0 :         free(c);
     133                 :          0 : }
     134                 :            : 
     135                 :            : /*
     136                 :            :  * Config files
     137                 :            :  */
     138                 :            : void
     139                 :        185 : pkg_config_file_free(struct pkg_config_file *c)
     140                 :            : {
     141         [ -  + ]:        185 :         if (c == NULL)
     142                 :          0 :                 return;
     143                 :            : 
     144                 :        185 :         free(c->content);
     145                 :        185 :         free(c);
     146                 :        185 : }
     147                 :            : 
     148                 :            : 
     149                 :            : /*
     150                 :            :  * kv
     151                 :            :  */
     152                 :            : 
     153                 :            : struct pkg_kv *
     154                 :       5225 : pkg_kv_new(const char *key, const char *val)
     155                 :            : {
     156                 :            :         struct pkg_kv *c;
     157                 :            : 
     158                 :       5225 :         c = xcalloc(1, sizeof(struct pkg_kv));
     159                 :       5225 :         c->key = xstrdup(key);
     160                 :       5225 :         c->value = xstrdup(val);
     161                 :            : 
     162                 :       5225 :         return (c);
     163                 :            : }
     164                 :            : 
     165                 :            : void
     166                 :       4691 : pkg_kv_free(struct pkg_kv *c)
     167                 :            : {
     168         [ -  + ]:       4691 :         if (c == NULL)
     169                 :          0 :                 return;
     170                 :            : 
     171                 :       4691 :         free(c->key);
     172                 :       4691 :         free(c->value);
     173                 :       4691 :         free(c);
     174                 :       4691 : }