Annotation of rpm2html/rpmdata.h, revision 1.45

1.1       veillard    1: /*
                      2:  * rpmdata.h : describes the data gathered for each RPM analyzed.
                      3:  *
1.32      veillard    4:  * See Copyright for the status of this software.
1.1       veillard    5:  *
1.45    ! daniel      6:  * $Id: rpmdata.h,v 1.44 1999/04/08 10:08:52 daniel Exp $
1.1       veillard    7:  */
                      8: 
                      9: #ifndef __RPMDATA_H__
                     10: #define __RPMDATA_H__
                     11: 
1.26      httpng     12: #include <sys/types.h>
1.44      daniel     13: #if defined(HAVE_RPM_RPMIO_H)
                     14: #include <rpm/rpmio.h>
                     15: #endif
1.1       veillard   16: #include <rpm/header.h>
                     17: 
                     18: /*
1.45    ! daniel     19:  * Structure associated with a local directory containing RPM files.
1.6       veillard   20:  */
                     21: 
1.16      veillard   22: #define MAX_ARCHS      (sizeof(int) * 8)
1.6       veillard   23: 
                     24: typedef struct rpm_dir {
                     25:     struct rpm_dir *next;      /* next in list */
1.14      veillard   26:     char *color;               /* The bgcolor for the pages :-) */
                     27:     char *dir;                 /* where to store the HTML files */
1.21      veillard   28:     char *subdir;              /* subdirectory for multiple archive */
1.8       veillard   29:     char *ftp;                 /* The host URL it's mirrored from */
                     30:     char *ftpsrc;              /* The host URL where src.rpm can be found */
1.14      veillard   31:     char *host;                 /* Hostname for the server */
                     32:     char *mail;                        /* mail contact for this directory */
                     33:     char *maint;               /* Maintainer name for this directory */
                     34:     char *name;                        /* Name for this repository */
                     35:     char *rpmdir;               /* The local repository */
1.6       veillard   36:     char *trust;               /* Confidences in the files */
1.14      veillard   37:     char *url;                 /* The output URL */
                     38:     int   files;               /* number of files */
                     39:     int   installbase;         /* Is this from an installed base */
                     40:     int   size;                        /* aggregated size of files */
                     41:     int   nb_mirrors;          /* numbers of mirrors */
1.29      veillard   42:     int   max_mirrors;         /* numbers of slot allocated */
                     43:     char **mirrors;             /* Urls for download */
1.35      daniel     44:     int   html;                        /* Should we build the HTML pages */
1.23      veillard   45:     int   build_tree;          /* Should we build the filesystem tree */
1.42      daniel     46:     int   follow_symlinks;     /* Should we follow all symlinks */
                     47:     int   rpm_symlinks;                /* Should we open links to RPM files */
1.23      veillard   48:     struct rpm_realdir *root;  /* The corresponding filesystem tree */
1.6       veillard   49: } rpmDir, *rpmDirPtr;
                     50: 
                     51: /*
1.45    ! daniel     52:  * Structure associated with a local directory containing HTML files.
1.22      veillard   53:  * We build a tree providing an actual map of the generated site.
                     54:  */
                     55: 
                     56: typedef struct rpm_subdir {
                     57:     struct rpm_subdir *parent; /* Parent directory ususally .. */
                     58:     char  *name;               /* subdirectory name */
                     59:     char  *color;              /* Color for the HTML output */
                     60:     char  *htmlpath;           /* full path w.r.t. rpm2html_url */
                     61:     char  *rpmpath;            /* full path w.r.t. rpm2html_dir */
1.36      daniel     62:     int    html;               /* Should we build the HTML pages */
1.22      veillard   63:     int    nb_subdirs;         /* number of subdirectories */
1.28      veillard   64:     int    max_subdirs;                /* number of subdirectories allocated */
                     65:     struct rpm_subdir **subdirs;/* list of the subdirectories */ 
1.22      veillard   66: } rpmSubdir, *rpmSubdirPtr;
                     67: 
                     68: /*
1.45    ! daniel     69:  * Structure associated with a real directory containing files owned
1.23      veillard   70:  * by RPM packages. It reflect the content of user's filesystem if
                     71:  * it installed the packages.
                     72:  */
                     73: 
                     74: #define RPM_ELEM_DIRECTORY     0x1   /* File or directory ? */
                     75: 
                     76: typedef struct rpm_realdir {
                     77:     struct rpm_realdir *parent;        /* Parent directory */
                     78:     char  *name;               /* directory name */
                     79:     int    nb_elem;            /* number of files (and subdirs)  */
                     80:     int    max_elem;           /* size of allocated arrays       */
                     81:                                 /* pointers to an array of either */
                     82:     void **elems;               /* filename or subdir rpm_realdir */
                     83:     char **names;               /* pointer to the array of names  */
                     84:     char  *flags;               /* pointer to array of flags      */
                     85: } rpmRealDir, *rpmRealDirPtr;
                     86: 
                     87: /*
1.13      veillard   88:  * structure associated with an architecture.
                     89:  */
                     90: 
                     91: typedef struct rpm_arch {
                     92:     struct rpm_arch *next;     /* next in the list */
                     93:     char *os;                  /* the Operating System name */
                     94:     char *arch;                        /* the CPU architecture */
                     95: } rpmArch, *rpmArchPtr;
                     96: 
                     97: /*
1.1       veillard   98:  * structure associated with an rpm
                     99:  */
                    100: 
                    101: typedef struct rpm_data {
1.16      veillard  102:     struct rpm_data *next;     /* next in the full list of RPMs */
                    103:     struct rpm_data *nextSoft; /* next software */
                    104:     struct rpm_data *nextArch; /* RPM for same software on other archs */
                    105:     struct rpm_data *nextHash; /* next in the hash list */
1.37      daniel    106:     /*
                    107:      * These informations need to be kept until the end of the processing
                    108:      * to allow the dump of resources directories.
                    109:      */
1.6       veillard  110:     rpmDirPtr dir;             /* directory infos */
1.37      daniel    111:     char *url;                  /* URL for the software */
1.2       veillard  112:     char *filename;            /* name of the file */
1.40      daniel    113:     const char *name;          /* name of the software */
1.37      daniel    114:     char *summary;             /* 1 line summary */
1.40      daniel    115:     const char *group;         /* type of software */
                    116:     const char *version;       /* version of the software */
                    117:     const char *release;       /* software release */
                    118:     const char *arch;           /* the architecture system */
                    119:     const char *os;             /* the target system */
                    120:     const char *distribution;  /* general OS distribution */
                    121:     const char *vendor;                /* general OS vendor */
1.37      daniel    122:     time_t date;               /* date of packaging */
                    123:     int_32 size;               /* size of the software */
1.40      daniel    124:     const char *subdir;                /* subdirectory holding the rpm */
1.37      daniel    125: 
                    126:     struct rpm_extra_data *extra;/* see below */
                    127: } rpmData, *rpmDataPtr;
                    128: 
                    129: typedef struct rpm_extra_data {
                    130:     /*
                    131:      * These informations are loaded and discarded as soon as the
                    132:      * HTML and RDF pages are built.
                    133:      */
1.8       veillard  134:     char *packager;            /* the packager */
1.2       veillard  135:     char *description;          /* short description */
1.8       veillard  136:     char *copyright;            /* software copyright */
1.20      veillard  137:     char *changelog;            /* changelog */
1.2       veillard  138:     char *srcrpm;              /* source RPM */
1.17      veillard  139:     time_t stamp;              /* modification file of the archive */
1.1       veillard  140:     char *host;                        /* build host */
1.29      veillard  141:     int   nb_resources;                /* #of resources provided */
                    142:     int   max_resources;       /* #of resources slot allocated */
                    143:     struct rpm_resource **resources;/* list of them */
1.19      veillard  144:     int   nb_requires;         /* #of resources required */
1.29      veillard  145:     int   max_requires;                /* #of resources slot allocated */
                    146:     struct rpm_resource **requires;/* list of them */
1.5       veillard  147:     char *filelist;             /* the filelist */
1.37      daniel    148: } rpmExtraData, *rpmExtraDataPtr;
1.1       veillard  149: 
                    150: /*
                    151:  * structure associated with a resource
                    152:  */
                    153: 
1.19      veillard  154: typedef struct rpm_resource {
                    155:     struct rpm_resource *next; /* next in the list */
1.41      daniel    156:     struct rpm_resource *nextHash;/* next in the hash table list */
1.19      veillard  157:     char *name;                        /* name of the resource */
                    158:     int   nb_provider;         /* #of resources provided */
1.29      veillard  159:     int   max_provider;                /* #of resources slot allocated */
1.17      veillard  160:     time_t stamp;              /* max stamp of the provider */
1.29      veillard  161:     struct rpm_data **provider; /* list of them */
1.1       veillard  162: } rpmRess, *rpmRessPtr;
                    163: 
                    164: 
1.30      veillard  165: /*
                    166:  * Variables.
                    167:  */
1.33      veillard  168: extern int   rpm2htmlVerbose;
1.30      veillard  169: extern int   force;
1.31      veillard  170: extern time_t currentTime;
1.30      veillard  171: 
1.16      veillard  172: extern const char *archNames[MAX_ARCHS];
                    173: extern int nbArchs;
                    174: 
                    175: extern rpmDataPtr rpmSoftwareList; /* avoid different archs clash */
1.1       veillard  176: extern rpmRessPtr ressList;
1.13      veillard  177: extern rpmArchPtr archList;
1.12      veillard  178: extern rpmRessPtr ressInstalledList;
1.6       veillard  179: extern rpmDirPtr dirList;
1.22      veillard  180: extern rpmSubdirPtr dirTree;
1.23      veillard  181: extern rpmRealDirPtr treeRoot;
1.22      veillard  182: 
1.30      veillard  183: /*
                    184:  * Functions
                    185:  */
1.22      veillard  186: extern rpmSubdirPtr rpmNewSubdir(rpmSubdirPtr dir, const char *name,
1.36      daniel    187:      const char *htmlpath, const char *rpmpath, const char *color, int html);
1.22      veillard  188: extern void rpmRemoveSubdir(rpmSubdirPtr tree);
                    189: extern void rpmFreeSubdir(rpmSubdirPtr tree);
1.1       veillard  190: 
1.16      veillard  191: extern void rpmAddSoftware(rpmDataPtr rpm);
1.1       veillard  192: extern void rpmDataPrint(rpmDataPtr rpm);
1.34      daniel    193: extern rpmDataPtr rpmSearchSoftware(const char *name, const char *version,
                    194:                                    const char *release, const char *arch);
1.8       veillard  195: /* extern void rpmDataPrintAll(void); */
1.12      veillard  196: extern rpmRessPtr rpmRessAdd(char *ress, rpmDataPtr rpm, int installed);
                    197: extern rpmRessPtr rpmRequAdd(char *requ, rpmDataPtr rpm, int installed);
1.13      veillard  198: extern rpmArchPtr rpmArchAdd(char *os, char *arch);
1.22      veillard  199: extern rpmDataPtr rpmOpen(char *nameRpm, rpmDirPtr dir, rpmSubdirPtr tree);
1.21      veillard  200: extern rpmDataPtr rpmDirScanAll(void);
1.8       veillard  201: extern char *extractEMail(char *string);
1.3       veillard  202: 
1.21      veillard  203: extern rpmDataPtr rpmAddList(rpmDataPtr old, rpmDataPtr newlist);
                    204: 
                    205: extern rpmDataPtr rpmGroupSort(rpmDataPtr list, int installed);
                    206: extern rpmDataPtr rpmDistribSort(rpmDataPtr list, int installed);
                    207: extern rpmDataPtr rpmVendorSort(rpmDataPtr list, int installed);
                    208: extern rpmDataPtr rpmDateSort(rpmDataPtr list, int installed);
                    209: extern rpmDataPtr rpmNameSort(rpmDataPtr list, int installed);
1.43      daniel    210: extern void rpmRessSort(rpmRessPtr ress);
1.1       veillard  211: 
1.24      veillard  212: extern rpmRealDirPtr rpmCreateRealRoot(void);
1.25      veillard  213: extern void rpmDestroyRealRoot(rpmRealDirPtr dir);
1.24      veillard  214: extern void rpmAddRealFile(rpmRealDirPtr root, const char *file,
                    215:                            rpmDataPtr rpm);
                    216: extern rpmRealDirPtr rpmMergeRealRoots(rpmRealDirPtr root1,
                    217:                                        rpmRealDirPtr root2);
1.38      daniel    218: extern void rpmFreeExtraData(rpmDataPtr rpm);
1.39      daniel    219: extern void rpmdataCleanup(void);
                    220: extern void rpmDataListFree(rpmDataPtr *base);
                    221: extern void rpmRessListFree(rpmRessPtr *base);
                    222: extern void rpmDirListFree(rpmDirPtr *base);
1.1       veillard  223: #endif /* __RPMDATA_H__ */

Webmaster