gboolean refreshStats(GList *hosts)
{
GList *ho;
gboolean r = TRUE;
static gboolean upd_pending = FALSE;
gboolean n_upd_pending = FALSE;
ho = g_list_first(hosts);
#ifdef FEAT_AUTOREF
static gboolean do_autoref = TRUE;
gint num_in_refresh = 0;
#endif
while(ho) {
HostNode *n = (HostNode *) ho->data;
if(screen_get_sessions(n)) {
if(n->category != C_SESSIONS) {
n->category = C_SESSIONS;
rebuilddl = TRUE;
}
}
else {
if(n->category == C_UPDATES_PENDING)
n_upd_pending = TRUE;
if (n->category == C_SESSIONS)
n->category = C_REFRESH_REQUIRED;
if(n->category == C_REFRESH_REQUIRED) {
/* Try to get a lock for the host. */
gint rsetlck = setLockForHost(n);
/* We don't got the lock. */
if(rsetlck == -1) {
n->status|= HOST_STATUS_LOCKED;
freePackages(n);
}
/* We got the lock. */
else if (rsetlck == 0) {
if(n->status & HOST_STATUS_LOCKED) {
refreshStatsOfNode(n);
/* n->status ^= HOST_STATUS_LOCKED; */
} else {
n->category = C_REFRESH;
rebuilddl = TRUE;
freePackages(n);
if(ssh_cmd_refresh(n) == FALSE) {
n->category = C_UNKNOWN;
}
}
/* Something weird happend. */
} else {
n->category = C_UNKNOWN;
rebuilddl = TRUE;
}
}
}
#ifdef FEAT_AUTOREF
if(n->category == C_REFRESH)
num_in_refresh++;
#endif
ho = g_list_next(ho);
}
#ifdef FEAT_TCLFILTER
applyFilter(hosts);
#endif
if(n_upd_pending && !upd_pending)
notifyUser();
upd_pending = n_upd_pending;
#ifdef FEAT_AUTOREF
if(cfg->auto_refresh) {
if (num_in_refresh == 0) {
if(do_autoref) {
if (autoref_trigger_auto())
drawStatus (_("Auto refresh triggered..."), FALSE);
do_autoref = FALSE;
}
}
else
do_autoref = TRUE;
}
#endif
return(r);
}
/* XXX should return rpmParseState, but RPMRC_FAIL forces int return. */
int parsePreamble(Spec spec, int initialPackage)
{
HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
rpmParseState nextPart;
int xx;
char *linep;
Package pkg;
char NVR[BUFSIZ];
char lang[BUFSIZ];
rpmRC rc;
strcpy(NVR, "(main package)");
pkg = newPackage(spec);
if (spec->packages == NULL) {
spec->packages = pkg;
assert(initialPackage);
} else if (! initialPackage) {
char *name = NULL;
rpmParseState flag;
Package lastpkg;
/* There is one option to %package: <pkg> or -n <pkg> */
flag = PART_NONE;
if (parseSimplePart(spec, &name, &flag)) {
rpmlog(RPMLOG_ERR, _("Bad package specification: %s\n"),
spec->line);
pkg = freePackages(pkg);
return RPMRC_FAIL;
}
lastpkg = NULL;
if (lookupPackage(spec, name, flag, &lastpkg) == RPMRC_OK) {
pkg->next = lastpkg->next;
} else {
/* Add package to end of list */
for (lastpkg = spec->packages; lastpkg->next != NULL; lastpkg = lastpkg->next)
{};
}
assert(lastpkg != NULL);
lastpkg->next = pkg;
/* Construct the package */
if (flag == PART_SUBNAME) {
he->tag = RPMTAG_NAME;
xx = headerGet(spec->packages->header, he, 0);
sprintf(NVR, "%s-%s", he->p.str, name);
he->p.ptr = _free(he->p.ptr);
} else
strcpy(NVR, name);
name = _free(name);
he->tag = RPMTAG_NAME;
he->t = RPM_STRING_TYPE;
he->p.str = NVR;
he->c = 1;
xx = headerPut(pkg->header, he, 0);
}
if ((rc = readLine(spec, STRIP_TRAILINGSPACE | STRIP_COMMENTS)) > 0) {
nextPart = PART_NONE;
} else {
if (rc)
return rc;
while ((nextPart = isPart(spec)) == PART_NONE) {
const char * macro = NULL;
rpmTag tag = 0;
/* Skip blank lines */
linep = spec->line;
SKIPSPACE(linep);
if (*linep != '\0') {
if (findPreambleTag(spec, &tag, ¯o, lang)) {
rpmlog(RPMLOG_ERR, _("line %d: Unknown tag: %s\n"),
spec->lineNum, spec->line);
return RPMRC_FAIL;
}
if (handlePreambleTag(spec, pkg, tag, macro, lang))
return RPMRC_FAIL;
if (spec->BANames && !spec->recursing && spec->toplevel)
return PART_BUILDARCHITECTURES;
}
if ((rc =
readLine(spec, STRIP_TRAILINGSPACE | STRIP_COMMENTS)) > 0) {
nextPart = PART_NONE;
break;
}
if (rc)
return rc;
}
}
/* Do some final processing on the header */
/*
* Expand buildroot one more time to get %{version} and the like
* from the main package.
*/
if (initialPackage) {
const char *s = rpmExpand("%{?buildroot}", NULL);
if (s && *s)
(void) addMacro(NULL, "buildroot", NULL, s, -1);
s = _free(s);
}
/* XXX Skip valid arch check if not building binary package */
if (!spec->anyarch && checkForValidArchitectures(spec))
return RPMRC_FAIL;
if (pkg == spec->packages)
fillOutMainPackage(pkg->header);
if (checkForDuplicates(pkg->header, NVR) != RPMRC_OK)
return RPMRC_FAIL;
if (pkg != spec->packages)
headerCopyTags(spec->packages->header, pkg->header,
(void *)copyTagsDuringParse);
#ifdef RPM_VENDOR_PLD /* rpm-epoch0 */
/* Add Epoch: 0 to package header if it was not set by spec */
he->tag = RPMTAG_NAME;
if (headerGet(spec->packages->header, he, 0) == 0) {
rpmuint32_t num = 0;
he->tag = RPMTAG_EPOCH;
he->t = RPM_UINT32_TYPE;
he->p.ui32p = #
he->c = 1;
xx = headerPut(pkg->header, he, 0);
/* also declare %{epoch} to be same */
addMacro(spec->macros, "epoch", NULL, "0", RMIL_SPEC);
}
#endif /* RPM_VENDOR_PLD rpm-epoch0 */
if (checkForRequired(pkg->header, NVR) != RPMRC_OK)
return RPMRC_FAIL;
return nextPart;
}
gboolean getUpdatesFromStat(HostNode *n)
{
char line[STATS_MAX_LINE_LEN];
char buf[256] = "\0";
FILE *fp;
PkgNode *pkgnode = NULL;
gint status=0, i;
gchar **argv = NULL;
gboolean adproto = FALSE;
gfloat adpver = 0;
gboolean adperr = FALSE;
if(!n) return (FALSE);
if(!getStatsFile(n)) {
n->category = C_UNKNOWN;
return (TRUE);
}
#ifdef FEAT_AUTOREF
struct stat sbuf;
if(!stat(n->statsfile, &sbuf))
n->last_upd = sbuf.st_mtime;
#endif
if(!(fp = (FILE *) g_fopen(n->statsfile, "r"))) {
n->category = C_UNKNOWN;
return (TRUE);
}
n->status = 0;
n->nupdates = 0;
n->nextras = 0;
n->nholds = 0;
n->nbrokens = 0;
n->forbid = 0;
n->uuid[0] = 0;
freePackages(n);
if(n->lsb_distributor) {
g_free(n->lsb_distributor);
n->lsb_distributor = NULL;
}
if(n->lsb_release) {
g_free(n->lsb_release);
n->lsb_release = NULL;
}
if(n->lsb_codename) {
g_free(n->lsb_codename);
n->lsb_codename = NULL;
}
if(n->uname_kernel) {
g_free(n->uname_kernel);
n->uname_kernel = NULL;
}
if(n->uname_machine) {
g_free(n->uname_machine);
n->uname_machine = NULL;
}
if(n->virt) {
g_free(n->virt);
n->virt = NULL;
}
if(n->adperr) {
g_free(n->adperr);
n->adperr = NULL;
}
if(n->kernelrel) {
g_free(n->kernelrel);
n->kernelrel = NULL;
}
#ifdef FEAT_CLUSTERS
cluster_host_reset(n);
#endif
int linesok = 0;
while(fgets(line, STATS_MAX_LINE_LEN, fp)) {
/* Remove any whitespace from the line. */
g_strchomp(line);
if (sscanf((gchar *) line, ADP_PATTERN_KERNELINFO, &status, buf) && !n->kernelrel) {
n->kernelrel = g_strdup(buf);
switch(status){
case 1:
n->status = n->status | HOST_STATUS_KERNELNOTMATCH;
break;
case 2:
n->status = n->status | HOST_STATUS_KERNELSELFBUILD;
break;
}
linesok++;
continue;
}
if(sscanf(line, ADP_PATTERN_ADPROTO, &adpver)) {
adproto = TRUE;
continue;
}
if(!strncmp("STATUS: ", line, 8)) {
argv = g_strsplit(&line[8], "|", 0);
if(!argv) continue;
i=0;
while(argv[i]) i++;
/* ignore invalid lines */
if(i < 3) {
g_strfreev(argv);
continue;
}
pkgnode = g_new0(PkgNode, 1);
#ifndef NDEBUG
pkgnode->_type = T_PKGNODE;
#endif
pkgnode->package = g_strdup(argv[0]);
pkgnode->version = g_strdup(argv[1]);
if (strlen(argv[2]) > 3)
pkgnode->data = g_strdup(&argv[2][2]);
switch(argv[2][0]) {
case 'u':
n->status = n->status | HOST_STATUS_PKGUPDATE;
pkgnode->flag = HOST_STATUS_PKGUPDATE;
n->nupdates++;
break;
case 'h':
n->status = n->status | HOST_STATUS_PKGKEPTBACK;
pkgnode->flag = HOST_STATUS_PKGKEPTBACK;
n->nholds++;
break;
case 'x':
n->status = n->status | HOST_STATUS_PKGEXTRA;
pkgnode->flag = HOST_STATUS_PKGEXTRA;
n->nextras++;
break;
case 'b':
n->status = n->status | HOST_STATUS_PKGBROKEN;
pkgnode->flag = HOST_STATUS_PKGBROKEN;
n->nbrokens++;
break;
case 'i':
break;
default:
g_free(pkgnode->package);
g_free(pkgnode->version);
g_free(pkgnode);
g_strfreev(argv);
continue;
}
g_strfreev(argv);
n->packages = g_list_insert_sorted(n->packages, pkgnode, cmpPackages);
linesok++;
continue;
}
if(!strncmp("LSBREL: ", line, 8)) {
argv = g_strsplit(&line[8], "|", 0);
if(!argv) continue;
i=0;
while(argv[i]) i++;
/* ignore invalid lines */
if(i < 3) {
g_strfreev(argv);
continue;
}
if(strlen(argv[0]) > 0) {
n->lsb_distributor = g_strdup(argv[0]);
n->lsb_release = g_strdup(argv[1]);
n->lsb_codename = g_strdup(argv[2]);
}
g_strfreev(argv);
linesok++;
continue;
}
if (sscanf((gchar *) line, ADP_PATTERN_VIRT, buf)) {
n->virt = g_strdup(buf);
if (strcmp(n->virt, "Unknown") && strcmp(n->virt, "Physical"))
n->status = n->status | HOST_STATUS_VIRTUALIZED;
linesok++;
continue;
}
if (sscanf((gchar *) line, ADP_PATTERN_ADPERR, buf)) {
n->adperr = g_strdup(buf);
adperr = TRUE;
continue;
}
if (sscanf((gchar *) line, ADP_PATTERN_UNAME, buf)) {
gchar *s = strchr(buf, '|');
if (s) {
s[0] = 0;
n->uname_kernel = g_strdup(buf);
n->uname_machine = g_strdup(s+1);
linesok++;
}
continue;
}
if (sscanf((gchar *) line, ADP_PATTERN_FORBID, &n->forbid))
continue;
if (sscanf((gchar *) line, "UUID: %" QUOTE(UUID_STRLEN) "s", n->uuid)) {
n->uuid[UUID_STRLEN-1] = 0;
linesok++;
continue;
}
#ifdef FEAT_CLUSTERS
char cluster[ADP_STRLEN_CLUSTER];
if (sscanf((gchar *) line, ADP_PATTERN_CLUSTER, cluster)) {
cluster[ADP_STRLEN_CLUSTER-1] = 0;
cluster_host_add(n, cluster);
linesok++;
continue;
}
#endif
}
if((!adproto && linesok > 10) ||
(adproto && adpver < ADP_FEATVER_ADPERR && linesok > 10) ||
(adproto && adpver >= ADP_FEATVER_ADPERR && !adperr)) {
if (n->status & HOST_STATUS_PKGBROKEN)
n->category = C_BROKEN_PKGS;
else if(n->status & HOST_STATUS_PKGUPDATE)
n->category = C_UPDATES_PENDING;
else
n->category = C_UP_TO_DATE;
#ifdef FEAT_AUTOREF
autoref_add_host_info(n);
#endif
}
else
n->category = C_UNKNOWN;
fclose(fp);
return(TRUE);
}
static void specFini(void * _spec)
/*@modifies _spec @*/
{
Spec spec = _spec;
struct ReadLevelEntry *rl;
if (spec == NULL) return; /* XXX assert? */
spec->lbuf = _free(spec->lbuf);
spec->sl = freeSl(spec->sl);
spec->st = freeSt(spec->st);
spec->prep = rpmiobFree(spec->prep);
spec->build = rpmiobFree(spec->build);
spec->install = rpmiobFree(spec->install);
spec->check = rpmiobFree(spec->check);
spec->clean = rpmiobFree(spec->clean);
spec->foo = tagStoreFree(spec->foo, spec->nfoo);
spec->nfoo = 0;
spec->buildSubdir = _free(spec->buildSubdir);
spec->rootURL = _free(spec->rootURL);
spec->specFile = _free(spec->specFile);
closeSpec(spec);
while (spec->readStack) {
rl = spec->readStack;
/*@-dependenttrans@*/
spec->readStack = rl->next;
/*@=dependenttrans@*/
rl->next = NULL;
rl = _free(rl);
}
spec->sourceRpmName = _free(spec->sourceRpmName);
spec->sourcePkgId = _free(spec->sourcePkgId);
spec->sourceHeader = headerFree(spec->sourceHeader);
if (spec->fi != NULL) {
rpmfi fi = spec->fi;
spec->fi = NULL;
fi = rpmfiFree(fi);
}
if (!spec->recursing) {
if (spec->BASpecs != NULL)
while (spec->BACount--) {
/*@-unqualifiedtrans@*/
spec->BASpecs[spec->BACount] =
freeSpec(spec->BASpecs[spec->BACount]);
/*@=unqualifiedtrans@*/
}
/*@-compdef@*/
spec->BASpecs = _free(spec->BASpecs);
/*@=compdef@*/
}
spec->BANames = _free(spec->BANames);
spec->passPhrase = _free(spec->passPhrase);
spec->cookie = _free(spec->cookie);
#ifdef WITH_LUA
{ rpmlua lua = NULL; /* global state */
rpmluaDelVar(lua, "patches");
rpmluaDelVar(lua, "sources");
}
#endif
spec->sources = freeSources(spec->sources);
spec->dig = pgpDigFree(spec->dig);
spec->packages = freePackages(spec->packages);
}
