sw-collector: Added --installed/removed options

diff --git a/src/sw-collector/sw-collector.8.in b/src/sw-collector/sw-collector.8.in
index a31c401947fc586c62f4ef9cc97a18ca57cea6cf..e5421229d4e0b5d92d4d674a563eb4810e63928f 100644 (file)
--- a/src/sw-collector/sw-collector.8.in
+++ b/src/sw-collector/sw-collector.8.in
@@ -15,7 +15,14 @@ sw-collector \- Extracts software installation events from dpkg history log
 .SY "sw-collector"
 .OP \-\-debug level
 .OP \-\-quiet
-.BR \-\-list |\fB\-\-unregistered\fR|\fB\-\-generate\fR|\fB\-\-migrate
+.OP \-\-installed\fR|\fB\--removed
+.BR \-\-list |\fB\-\-unregistered\fR|\fB\-\-generate
+.YS
+.
+.SY "sw-collector"
+.OP \-\-debug level
+.OP \-\-quiet
+.BR \-\-migrate
 .YS
 .
 .SY "sw-collector"
@@ -44,6 +51,12 @@ Set debug level, default: 2.
 .B "\-q, \-\-quiet
 Disable debug output to stderr.
 .TP
+.B "\-i, \-\-installed
+Apply command to installed software packages, only.
+.TP
+.B "\-r, \-\-removed
+Apply command to removed software packages, only.
+.TP
 .B "\-l, \-\-list
 Lists all software packages stored in the collector database showing their
 installation status.
@@ -54,8 +67,8 @@ which no SWID tags exist yet in a central collector database reachable via a
 REST interface. 
 .TP
 .B "\-g, \-\-generate
-Generates minimal SWID tags for all deleted software packages residing in the
-local collector database but for which no SWID tags exist in a central collector
+Generates minimal SWID tags for all software packages residing in the local
+collector database but for which no SWID tags exist in a central collector
 database reachable via a REST interface.
 .TP
 .B "\-m, \-\-migrate

diff --git a/src/sw-collector/sw-collector.c b/src/sw-collector/sw-collector.c
index d76f7516102c79eeacf32325820a76dbc507c79d..bb393961906d4581574851b7f6847365ef327061 100644 (file)
--- a/src/sw-collector/sw-collector.c
+++ b/src/sw-collector/sw-collector.c
@@ -116,16 +116,19 @@ static void usage(void)
 Usage:\n\
   sw-collector --help\n\
   sw-collector [--debug <level>] [--quiet] [--count <event count>]\n\
-  sw-collector [--debug <level>] [--quiet] --list|-unregistered\n\
-  sw-collector [--debug <level>] [--quiet] ---generate|--migrate\n");
+  sw-collector [--debug <level>] [--quiet] [--installed|--removed] \
+--list|-unregistered|--generate\n\
+  sw-collector [--debug <level>] [--quiet] --migrate\n");
 }
 
 /**
  * Parse command line options
  */
-static collector_op_t do_args(int argc, char *argv[])
+static collector_op_t do_args(int argc, char *argv[],
+                                                         sw_collector_db_query_t *query_type)
 {
        collector_op_t op = COLLECTOR_OP_EXTRACT;
+       bool installed = FALSE, removed = FALSE;
 
        /* reinit getopt state */
        optind = 0;
@@ -139,14 +142,16 @@ static collector_op_t do_args(int argc, char *argv[])
                        { "count", required_argument, NULL, 'c' },
                        { "debug", required_argument, NULL, 'd' },
                        { "generate", no_argument, NULL, 'g' },
+                       { "installed", no_argument, NULL, 'i' },
                        { "list", no_argument, NULL, 'l' },
                        { "migrate", no_argument, NULL, 'm' },
                        { "quiet", no_argument, NULL, 'q' },
+                       { "removed", no_argument, NULL, 'r' },
                        { "unregistered", no_argument, NULL, 'u' },
                        { 0,0,0,0 }
                };
 
-               c = getopt_long(argc, argv, "hc:d:lmqu", long_opts, NULL);
+               c = getopt_long(argc, argv, "hc:d:gilmqru", long_opts, NULL);
                switch (c)
                {
                        case EOF:
@@ -164,6 +169,9 @@ static collector_op_t do_args(int argc, char *argv[])
                        case 'g':
                                op = COLLECTOR_OP_GENERATE;
                                continue;
+                       case 'i':
+                               installed = TRUE;
+                               continue;
                        case 'l':
                                op = COLLECTOR_OP_LIST;
                                continue;
@@ -173,6 +181,9 @@ static collector_op_t do_args(int argc, char *argv[])
                        case 'q':
                                stderr_quiet = TRUE;
                                continue;
+                       case 'r':
+                               removed = TRUE;
+                               continue;
                        case 'u':
                                op = COLLECTOR_OP_UNREGISTERED;
                                continue;
@@ -182,6 +193,18 @@ static collector_op_t do_args(int argc, char *argv[])
                }
                break;
        }
+       if ((!installed && !removed) || (installed && removed))
+       {
+               *query_type = SW_QUERY_ALL;
+       }
+       else if (installed)
+       {
+               *query_type = SW_QUERY_INSTALLED;
+       }
+       else
+       {
+               *query_type = SW_QUERY_REMOVED;
+       }
        return op;
 }
 
@@ -337,13 +360,13 @@ end:
 /**
  * List all endpoint software identifiers stored in local collector database
  */
-static int list_identifiers(sw_collector_db_t *db)
+static int list_identifiers(sw_collector_db_t *db, sw_collector_db_query_t type)
 {
        enumerator_t *e;
        char *name, *package, *version;
-       uint32_t sw_id, count = 0, installed_count = 0, installed;
+       uint32_t sw_id, count = 0, installed_count = 0, removed_count, installed;
 
-       e = db->create_sw_enumerator(db, SW_QUERY_ALL, NULL);
+       e = db->create_sw_enumerator(db, type, NULL);
        if (!e)
        {
                return EXIT_FAILURE;
@@ -357,9 +380,22 @@ static int list_identifiers(sw_collector_db_t *db)
                }
                count++;
        }
+       removed_count = count - installed_count;
        e->destroy(e);
-       DBG1(DBG_IMC, "retrieved %u software identities with %u installed and %u "
-                                 "deleted", count, installed_count, count - installed_count);
+
+       switch (type)
+       {
+               case SW_QUERY_ALL:
+                       DBG1(DBG_IMC, "retrieved %u software identities with %u installed "
+                                "and %u removed", count, installed_count, removed_count);
+                       break;
+               case SW_QUERY_INSTALLED:
+                       DBG1(DBG_IMC, "retrieved %u installed software identities", count);
+                       break;
+               case SW_QUERY_REMOVED:
+                       DBG1(DBG_IMC, "retrieved %u removed software identities", count);
+                       break;
+       }
 
        return EXIT_SUCCESS;
 }
@@ -371,7 +407,7 @@ static bool query_registry(sw_collector_rest_api_t *rest_api, bool installed)
        char *sw_id;
        int count = 0;
 
-       type = installed ? SW_QUERY_INSTALLED : SW_QUERY_DELETED;
+       type = installed ? SW_QUERY_INSTALLED : SW_QUERY_REMOVED;
        enumerator = rest_api->create_sw_enumerator(rest_api, type);
        if (!enumerator)
        {
@@ -384,7 +420,7 @@ static bool query_registry(sw_collector_rest_api_t *rest_api, bool installed)
        }
        enumerator->destroy(enumerator);
        DBG1(DBG_IMC, "%d %s software identifiers not registered", count,
-                                  installed ? "installed" : "deleted");
+                                  installed ? "installed" : "removed");
        return TRUE;
 }
 
@@ -393,7 +429,8 @@ static bool query_registry(sw_collector_rest_api_t *rest_api, bool installed)
  * List all endpoint software identifiers stored in local collector database
  * that are not registered yet in central collelector database
  */
-static int unregistered_identifiers(sw_collector_db_t *db)
+static int unregistered_identifiers(sw_collector_db_t *db,
+                                                                       sw_collector_db_query_t type)
 {
        sw_collector_rest_api_t *rest_api;
        int status = EXIT_SUCCESS;
@@ -405,13 +442,13 @@ static int unregistered_identifiers(sw_collector_db_t *db)
        }
 
        /* List installed software identifiers not registered centrally */
-       if (!query_registry(rest_api, TRUE))
+       if (type != SW_QUERY_REMOVED && !query_registry(rest_api, TRUE))
        {
                status = EXIT_FAILURE;
        }
 
-       /* List deleted software identifiers not registered centrally */
-       if (!query_registry(rest_api, FALSE))
+       /* List removed software identifiers not registered centrally */
+       if (type != SW_QUERY_INSTALLED && !query_registry(rest_api, FALSE))
        {
                status = EXIT_FAILURE;
        }
@@ -450,15 +487,17 @@ static char* generate_tag(char *name, char *package, char *version,
 
 /**
  * Generate a minimalistic ISO 19770-2:2015 SWID tag for
- * all deleted SW identifiers that are not registered centrally
+ * all removed SW identifiers that are not registered centrally
  */
-static int generate_tags(sw_collector_info_t *info, sw_collector_db_t *db)
+static int generate_tags(sw_collector_info_t *info, sw_collector_db_t *db,
+                                                sw_collector_db_query_t type)
 {
        sw_collector_rest_api_t *rest_api;
-       char *pos, *name, *package, *version, *entity, *regid, *product, *tag;
+       char *name, *package, *version, *entity, *regid, *product, *tag;
        enumerator_t *enumerator;
        uint32_t sw_id;
-       int status = EXIT_FAILURE;
+       bool installed;
+       int count = 0, installed_count = 0, status = EXIT_FAILURE;
 
        entity = lib->settings->get_str(lib->settings, "%s.tag_creator.name",
                                                                        "strongSwan Project", lib->ns);
@@ -472,28 +511,26 @@ static int generate_tags(sw_collector_info_t *info, sw_collector_db_t *db)
                goto end;
        }
 
-       enumerator = rest_api->create_sw_enumerator(rest_api, SW_QUERY_DELETED);
+       enumerator = rest_api->create_sw_enumerator(rest_api, type);
        if (!enumerator)
        {
                goto end;
        }
        while (enumerator->enumerate(enumerator, &name))
        {
-               sw_id = db->get_sw_id(db, name, &package, &version, NULL, NULL);
+               sw_id = db->get_sw_id(db, name, &package, &version, NULL, &installed);
                if (sw_id)
                {
-                       /* Remove architecture from package name */
-                       pos = strchr(package, ':');
-                       if (pos)
-                       {
-                               *pos = '\0';
-                       }
                        tag = generate_tag(name, package, version, entity, regid, product);
                        if (tag)
                        {
                                printf("%s\n", tag);
                                free(tag);
                                count++;
+                               if (installed)
+                               {
+                                       installed_count++;
+                               }
                        }
                        free(package);
                        free(version);
@@ -501,8 +538,23 @@ static int generate_tags(sw_collector_info_t *info, sw_collector_db_t *db)
        }
        enumerator->destroy(enumerator);
        status = EXIT_SUCCESS;
-       DBG1(DBG_IMC, "%d tags for deleted unregistered software identifiers",
-                                  count);
+
+       switch (type)
+       {
+               case SW_QUERY_ALL:
+                       DBG1(DBG_IMC, "%d tags for unregistered software identifiers with "
+                                "%d installed and %d removed", count, installed_count,
+                                count - installed_count);
+                       break;
+               case SW_QUERY_INSTALLED:
+                       DBG1(DBG_IMC, "%d tags for unregistered installed software "
+                                "identifiers", count);
+                       break;
+               case SW_QUERY_REMOVED:
+                       DBG1(DBG_IMC, "%d tags for unregistered removed software "
+                                "identifiers", count);
+                       break;
+       }
 
 end:
        DESTROY_IF(rest_api);
@@ -560,12 +612,13 @@ static int migrate(sw_collector_info_t *info, sw_collector_db_t *db)
 int main(int argc, char *argv[])
 {
        sw_collector_db_t *db = NULL;
+       sw_collector_db_query_t query_type;
        sw_collector_info_t *info;
        collector_op_t op;
        char *uri, *tag_creator;
        int status = EXIT_FAILURE;
 
-       op = do_args(argc, argv);
+       op = do_args(argc, argv, &query_type);
 
        /* enable sw_collector debugging hook */
        dbg = sw_collector_dbg;
@@ -613,13 +666,13 @@ int main(int argc, char *argv[])
                        status = extract_history(info, db);
                        break;
                case COLLECTOR_OP_LIST:
-                       status = list_identifiers(db);
+                       status = list_identifiers(db, query_type);
                        break;
                case COLLECTOR_OP_UNREGISTERED:
-                       status = unregistered_identifiers(db);
+                       status = unregistered_identifiers(db, query_type);
                        break;
                case COLLECTOR_OP_GENERATE:
-                       status = generate_tags(info, db);
+                       status = generate_tags(info, db, query_type);
                        break;
                case COLLECTOR_OP_MIGRATE:
                        status = migrate(info, db);

diff --git a/src/sw-collector/sw_collector_db.h b/src/sw-collector/sw_collector_db.h
index 7aa41b0c165a8bfbdf4faac3c7acb7dcf1cb75b2..0b9ed474d0637874c26d3fd3cddde7547ceae501 100644 (file)
--- a/src/sw-collector/sw_collector_db.h
+++ b/src/sw-collector/sw_collector_db.h
@@ -32,7 +32,7 @@ typedef enum sw_collector_db_query_t sw_collector_db_query_t;
 enum sw_collector_db_query_t {
        SW_QUERY_ALL,
        SW_QUERY_INSTALLED,
-       SW_QUERY_DELETED
+       SW_QUERY_REMOVED
 };
 
 /**
@@ -97,9 +97,9 @@ struct sw_collector_db_t {
                                                  char **version, uint8_t *source, bool *installed);
 
        /**
-        * Get number of installed or deleted software identifiers
+        * Get number of installed or removed software identifiers
         *
-        * @param type                  Query type (ALL, INSTALLED, DELETED)
+        * @param type                  Query type (ALL, INSTALLED, REMOVED)
         * @return                              Count
         */
        uint32_t (*get_sw_id_count)(sw_collector_db_t *this,
@@ -130,7 +130,7 @@ struct sw_collector_db_t {
        /**
         * Enumerate over all collected [installed] software identities
         *
-        * @param type                  Query type (ALL, INSTALLED, DELETED)
+        * @param type                  Query type (ALL, INSTALLED, REMOVED)
         * @param package               If not NULL enumerate over all package versions
         * @return                              Enumerator
         */

diff --git a/src/sw-collector/sw_collector_history.c b/src/sw-collector/sw_collector_history.c
index 71f888c465c02da274fc75e94cf768540b6e2045..832b2c117baf6aed12ed39ef5fc17d9046b5a529 100644 (file)
--- a/src/sw-collector/sw_collector_history.c
+++ b/src/sw-collector/sw_collector_history.c
@@ -329,7 +329,7 @@ METHOD(sw_collector_history_t, extract_packages, bool,
                        }
                        if (sw_id)
                        {
-                               /* sw identifier exists - update state to 'deleted' */
+                               /* sw identifier exists - update state to 'removed' */
                                if (!this->db->update_sw_id(this->db, sw_id, NULL, NULL, FALSE))
                                {
                                        goto end;
@@ -337,7 +337,7 @@ METHOD(sw_collector_history_t, extract_packages, bool,
                        }
                        else
                        {
-                               /* new sw identifier - create with state 'deleted' */
+                               /* new sw identifier - create with state 'removed' */
                                sw_id = this->db->set_sw_id(this->db, del_sw_id, p->package,
                                                                        del_version, this->source, FALSE);
 

diff --git a/src/sw-collector/sw_collector_rest_api.h b/src/sw-collector/sw_collector_rest_api.h
index ca45230e63d0bcc95492ee9903d4c77a4cb38b00..8463871b17da96bda013ad66fd68eac5f2628029 100644 (file)
--- a/src/sw-collector/sw_collector_rest_api.h
+++ b/src/sw-collector/sw_collector_rest_api.h
@@ -34,7 +34,7 @@ struct sw_collector_rest_api_t {
         * List of locally stored software identifiers that are not registered
         * in a central collector database
         *
-        * @param type                  Query type (ALL, INSTALLED, DELETED)
+        * @param type                  Query type (ALL, INSTALLED, REMOVED)
         * @return                              Enumerator
         */
        enumerator_t* (*create_sw_enumerator)(sw_collector_rest_api_t *this,