void debug_scan(char *msg, scan_t *scan) {
debug_trace(msg,
"id=%s off=%d prefix=%-3d header=%-3d gap=%-3d payload=%-3d post=%-3d "
"nid=%s buf_len=%-3d wire_len=%-3d flags=%0x",
id2str(scan->id), scan->offset, scan->hdr_prefix, scan->length,
scan->hdr_gap, scan->hdr_payload, scan->hdr_postfix, id2str(
scan->next_id), scan->buf_len, scan->wire_len,
scan->scanner->sc_flags[scan->id]);
}
int
pool_evrcmp(const Pool *pool, Id evr1id, Id evr2id, int mode)
{
const char *evr1, *evr2;
if (evr1id == evr2id)
return 0;
evr1 = id2str(pool, evr1id);
evr2 = id2str(pool, evr2id);
return evrcmp_str(pool, evr1, evr2, mode);
}
static void
doquery(Pool *pool, Repo *repo, const char *query)
{
Id id, type = 0;
char qbuf[256];
const char *qp;
Dataiterator di;
qp = strchr(query, ':');
if (qp)
{
type = strn2id(pool, query, qp - query, 0);
if (!type)
exit(0);
qp++;
}
else
qp = query;
snprintf(qbuf, sizeof(qbuf), "repository:repomd:%s", qp);
id = str2id(pool, qbuf, 0);
if (!id)
exit(0);
dataiterator_init(&di, pool, repo, SOLVID_META, id, 0, 0);
dataiterator_prepend_keyname(&di, REPOSITORY_REPOMD);
while (dataiterator_step(&di))
{
if (type)
{
dataiterator_setpos_parent(&di);
if (pool_lookup_id(pool, SOLVID_POS, REPOSITORY_REPOMD_TYPE) != type)
continue;
}
switch (di.key->type)
{
case REPOKEY_TYPE_ID:
case REPOKEY_TYPE_CONSTANTID:
printf("%s\n", id2str(pool, di.kv.id));
break;
case REPOKEY_TYPE_STR:
printf("%s\n", di.kv.str);
break;
case REPOKEY_TYPE_NUM:
printf("%d\n", di.kv.num);
break;
case REPOKEY_TYPE_SHA1:
printf("sha1:%s\n", repodata_chk2str(di.data, di.key->type, (unsigned char *)di.kv.str));
break;
case REPOKEY_TYPE_SHA256:
printf("sha256:%s\n", repodata_chk2str(di.data, di.key->type, (unsigned char *)di.kv.str));
break;
default:
break;
}
}
dataiterator_free(&di);
}
static void
set_sourcerpm(Repodata *data, Solvable *s, Id handle, char *sourcerpm)
{
const char *p, *sevr, *sarch, *name, *evr;
Pool *pool;
p = strrchr(sourcerpm, '.');
if (!p || strcmp(p, ".rpm") != 0)
return;
p--;
while (p > sourcerpm && *p != '.')
p--;
if (*p != '.' || p == sourcerpm)
return;
sarch = p-- + 1;
while (p > sourcerpm && *p != '-')
p--;
if (*p != '-' || p == sourcerpm)
return;
p--;
while (p > sourcerpm && *p != '-')
p--;
if (*p != '-' || p == sourcerpm)
return;
sevr = p + 1;
pool = s->repo->pool;
if (!strcmp(sarch, "src.rpm"))
repodata_set_constantid(data, handle, SOLVABLE_SOURCEARCH, ARCH_SRC);
else if (!strcmp(sarch, "nosrc.rpm"))
repodata_set_constantid(data, handle, SOLVABLE_SOURCEARCH, ARCH_NOSRC);
else
repodata_set_constantid(data, handle, SOLVABLE_SOURCEARCH, strn2id(pool, sarch, strlen(sarch) - 4, 1));
evr = id2str(pool, s->evr);
if (evr && !strncmp(sevr, evr, sarch - sevr - 1) && evr[sarch - sevr - 1] == 0)
repodata_set_void(data, handle, SOLVABLE_SOURCEEVR);
else
repodata_set_id(data, handle, SOLVABLE_SOURCEEVR, strn2id(pool, sevr, sarch - sevr - 1, 1));
name = id2str(pool, s->name);
if (name && !strncmp(sourcerpm, name, sevr - sourcerpm - 1) && name[sevr - sourcerpm - 1] == 0)
repodata_set_void(data, handle, SOLVABLE_SOURCENAME);
else
repodata_set_id(data, handle, SOLVABLE_SOURCENAME, strn2id(pool, sourcerpm, sevr - sourcerpm - 1, 1));
}
static unsigned int
adddep(Pool *pool, struct parsedata *pd, unsigned int olddeps, const char **atts, int isreq)
{
Id id, name, marker;
const char *n, *f, *k;
const char **a;
n = f = k = 0;
marker = isreq ? -SOLVABLE_PREREQMARKER : 0;
for (a = atts; *a; a += 2)
{
if (!strcmp(*a, "name"))
n = a[1];
else if (!strcmp(*a, "flags"))
f = a[1];
else if (!strcmp(*a, "kind"))
k = a[1];
else if (isreq && !strcmp(*a, "pre") && a[1][0] == '1')
marker = SOLVABLE_PREREQMARKER;
}
if (!n)
return olddeps;
if (k && !strcmp(k, "package"))
k = 0;
if (k)
{
int l = strlen(k) + 1 + strlen(n) + 1;
if (l > pd->acontent)
{
pd->content = sat_realloc(pd->content, l + 256);
pd->acontent = l + 256;
}
sprintf(pd->content, "%s:%s", k, n);
name = str2id(pool, pd->content, 1);
}
else
name = str2id(pool, (char *)n, 1);
if (f)
{
Id evr = makeevr_atts(pool, pd, atts);
int flags;
for (flags = 0; flags < 6; flags++)
if (!strcmp(f, flagtab[flags]))
break;
flags = flags < 6 ? flags + 1 : 0;
id = rel2id(pool, name, evr, flags, 1);
}
else
id = name;
#if 0
fprintf(stderr, "new dep %s%s%s\n", id2str(pool, d), id2rel(pool, d), id2evr(pool, d));
#endif
return repo_addid_dep(pd->common.repo, olddeps, id, marker);
}
/*
* Class: org_jnetpcap_packet_JHeaderScanner
* Method: bindNativeScanner
* Signature: (I)V
*/
JNIEXPORT void JNICALL Java_org_jnetpcap_packet_JHeaderScanner_bindNativeScanner
(JNIEnv *env, jobject obj, jint id) {
if (id < 0 || id > MAX_ID_COUNT) {
sprintf(str_buf, "invalid ID=%d (%s)", id, id2str(id));
throwException(env, UNREGISTERED_SCANNER_EXCEPTION, str_buf);
return;
}
if (native_protocols[id] == NULL) {
sprintf(str_buf, "native scanner not registered under ID=%d (%s)",
id,
id2str(id));
throwException(env, UNREGISTERED_SCANNER_EXCEPTION, str_buf);
return;
}
setJMemoryPhysical(env, obj, toLong((void *)native_protocols[id]));
}
int
pool_evrmatch(const Pool *pool, Id evrid, const char *epoch, const char *version, const char *release)
{
const char *evr1;
const char *s1;
const char *r1;
int r;
evr1 = id2str(pool, evrid);
for (s1 = evr1; *s1 >= '0' && *s1 <= '9'; s1++)
;
if (s1 != evr1 && *s1 == ':')
{
if (epoch)
{
r = vercmp(evr1, s1, epoch, epoch + strlen(epoch));
if (r)
return r;
}
evr1 = s1 + 1;
}
else if (epoch)
{
while (*epoch == '0')
epoch++;
if (*epoch)
return -1;
}
for (s1 = evr1, r1 = 0; *s1; s1++)
if (*s1 == '-')
r1 = s1;
if (version)
{
r = vercmp(evr1, r1 ? r1 : s1, version, version + strlen(version));
if (r)
return r;
}
if (release)
{
if (!r1)
return -1;
r = vercmp(r1 + 1, s1, release, release + strlen(release));
if (r)
return r;
}
return 0;
}
int main()
{
Pool *pool;
Repo *installed;
Solvable *s;
Id p;
int i;
Queue todo, conflicts;
void *state = 0;
pool = pool_create();
pool_setdebuglevel(pool, 1);
installed = repo_create(pool, "@System");
pool_set_installed(pool, installed);
repo_add_rpmdb(installed, 0, 0, 0);
queue_init(&todo);
queue_init(&conflicts);
FOR_REPO_SOLVABLES(installed, p, s)
queue_push(&todo, p);
pool_findfileconflicts(pool, &todo, 0, &conflicts, &iterate_handle, (void *)&state);
queue_free(&todo);
for (i = 0; i < conflicts.count; i += 5)
printf("%s: %s[%s] %s[%s]\n", id2str(pool, conflicts.elements[i]), solvid2str(pool, conflicts.elements[i + 1]), id2str(pool, conflicts.elements[i + 2]), solvid2str(pool, conflicts.elements[i + 3]), id2str(pool, conflicts.elements[i + 4]));
if (conflicts.count)
{
Queue job;
queue_init(&job);
pool_add_fileconflicts_deps(pool, &conflicts);
pool_addfileprovides(pool);
pool_createwhatprovides(pool);
pool_setdebuglevel(pool, 0);
Solver *solv = solver_create(pool);
solv->fixsystem = 1;
#if 0
solv->allowuninstall = 1;
#endif
solver_solve(solv, &job);
if (solv->problems.count)
solver_printallsolutions(solv);
else
solver_printtransaction(solv);
queue_free(&job);
solver_free(solv);
}
queue_free(&conflicts);
exit(0);
}
void host_to_overview (host *h, var *ovdict) {
char mid[16];
char uuidstr[40];
uuid2str (h->uuid, uuidstr);
var *res = var_get_dict_forkey (ovdict, uuidstr);
meter *m = h->first;
while (m) {
if (m->count >= SZ_EMPTY_VAL) {
m = m->next;
continue;
}
id2str (m->id, mid);
if ((strncmp (mid, "top/", 4) == 0) ||
(strncmp (mid, "df/", 3) == 0) ||
(strncmp (mid, "proc/", 5) == 0) ||
(strncmp (mid, "os/", 3) == 0) ||
(strncmp (mid, "who/", 4) == 0)) {
m = m->next;
continue;
}
switch (m->id & MMASK_TYPE) {
case MTYPE_INT:
var_set_int_forkey (res, mid, meter_get_uint (m, 0));
break;
case MTYPE_FRAC:
var_set_double_forkey (res, mid, meter_get_frac (m, 0));
break;
case MTYPE_STR:
var_set_str_forkey (res, mid, m->d.str[0].str);
break;
default:
break;
}
m = m->next;
}
}
/**
* Scan packet buffer by dispatching to JBinding java objects
*/
void callJavaHeaderScanner(scan_t *scan) {
#ifdef DEBUG
debug_enter("callJavaHeaderScanner");
#endif
JNIEnv *env = scan->env;
jobject jscanner = scan->scanner->sc_java_header_scanners[scan->id];
if (jscanner == NULL) {
sprintf(str_buf, "java header scanner not set for ID=%d (%s)",
scan->id, id2str(scan->id));
#ifdef DEBUG
debug_error("callJavaHeaderScanner()", str_buf);
#endif
throwException(scan->env, NULL_PTR_EXCEPTION, str_buf);
return;
}
env->CallVoidMethod(jscanner, scanHeaderMID, scan->scanner->sc_jscan);
#ifdef DEBUG
debug_exit("callJavaHeaderScanner");
#endif
}
/*
* Class: org_jnetpcap_packet_JPacket_State
* Method: toDebugStringJPacketState
* Signature: ()Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_org_jnetpcap_packet_JPacket_00024State_toDebugStringJPacketState
(JNIEnv *env, jobject obj) {
char buf[15 * 1024];
buf[0] = '\0';
packet_state_t *packet = (packet_state_t *)getJMemoryPhysical(env, obj);
if (packet == NULL) {
return NULL;
}
int fr = packet->pkt_frame_num;
sprintf(buf,
"JPacket.State#%03d: sizeof(packet_state_t)=%d\n"
"JPacket.State#%03d: sizeof(header_t)=%d and *%d=%d\n"
"JPacket.State#%03d: pkt_header_map=0x%X\n"
"JPacket.State#%03d: pkt_flags=0x%x\n"
"JPacket.State#%03d: pkt_header_count=%d\n"
"JPacket.State#%03d: pkt_wirelen=%d\n",
fr, (int) sizeof(packet_state_t),
fr, (int) sizeof(header_t),
(int) packet->pkt_header_count,
(int) sizeof(header_t) * packet->pkt_header_count,
fr, (int) packet->pkt_header_map,
fr, (int) packet->pkt_flags,
fr, (int) packet->pkt_header_count,
fr, (int) packet->pkt_wirelen);
char *p = buf;
if (packet->pkt_header_count> 32) {
sprintf(buf + strlen(buf),
"JPacket.State#%03d: TOO MANY HEADERS (more than 32)",
fr);
return env->NewStringUTF(buf);
}
p = buf + strlen(buf);
sprintf(p,
"JPacket.State#%03d : "
"[%10s(%2s/%4s) | %4s |"
"%7s |"
"%7s |"
"%4s | "
"%7s | "
"%7s ]\n",
fr,
"Protocol",
"ID",
"Flag",
"Start",
"Prefix",
"Header",
"Gap",
"Payload",
"Postfix"
);
for (int i = 0; i < packet->pkt_header_count; i ++) {
p = buf + strlen(buf);
sprintf(p,
"JPacket.State#%03d[%d]: "
"[%10s(%2d/%04X) | %5d | "
"%6d | "
"%6d | "
"%3d | "
"%7d | "
"%7d ]\n",
fr, i,
id2str(packet->pkt_headers[i].hdr_id),
packet->pkt_headers[i].hdr_id,
packet->pkt_headers[i].hdr_flags,
packet->pkt_headers[i].hdr_offset,
packet->pkt_headers[i].hdr_prefix,
packet->pkt_headers[i].hdr_length,
packet->pkt_headers[i].hdr_gap,
packet->pkt_headers[i].hdr_payload,
packet->pkt_headers[i].hdr_postfix
);
}
return env->NewStringUTF(buf);
}
/**
* Scan packet buffer
*/
int scan(JNIEnv *env, jobject obj, jobject jpacket, scanner_t *scanner,
packet_state_t *p_packet, int first_id, char *buf, int buf_len,
uint32_t wirelen) {
scan_t scan; // Our current in progress scan's state information
scan_t *pscan = &scan;
scan.env = env;
scan.jscanner = obj;
scan.jpacket = jpacket;
scan.scanner = scanner;
scan.packet = p_packet;
scan.header = &p_packet->pkt_headers[0];
scan.buf = buf;
scan.buf_len = buf_len; // Changing buffer length, reduced by 'postfix'
scan.mem_len = buf_len; // Constant in memory buffer length
scan.wire_len = wirelen;
scan.offset = 0;
scan.length = 0;
scan.id = first_id;
scan.next_id = PAYLOAD_ID;
scan.flags = 0;
scan.stack_index = 0;
scan.hdr_count = 0;
scan.hdr_flags = 0;
scan.hdr_prefix = 0;
scan.hdr_gap = 0;
scan.hdr_payload = 0;
scan.hdr_postfix = 0;
memset(scan.header, 0, sizeof(header_t));
// Point jscan
setJMemoryPhysical(env, scanner->sc_jscan, toLong(&scan));
// Local temp variables
register uint64_t mask;
#ifdef DEBUG
debug_enter("scan");
debug_trace("processing packet", "#%d", p_packet->pkt_frame_num);
#endif
/*
* Main scanner loop, 1st scans for builtin header types then
* reverts to calling on JBinding objects to provide the binding chain
*/
while (scan.id != END_OF_HEADERS) {
#ifdef DEBUG
debug_trace("", "");
debug_trace("processing header", id2str(scan.id));
debug_scan("loop-top", &scan);
#endif
/* A flag that keeps track of header recording. Set in record_header()*/
scan.is_recorded = 0;
/*
* If debugging is compiled in, we can also call on each protocols
* debug_* function to print out details about the protocol header
* structure.
*/
#ifdef DEBUG
if (native_debug[scan.id]) {
native_debug[scan.id](scan.buf + scan.offset);
}
#endif
/*
* Scan of each protocol is done through a dispatch function table.
* Each protocol that has a protocol header scanner attached, a scanner
* designed specifically for that protocol. The protocol id is also the
* index into the table. There are 2 types of scanners both have exactly
* the same signature and thus both are set in this table. The first is
* the native scanner that only performs a direct scan of the header.
* The second scanner is a java header scanner. It is based on
* JHeaderScanner class. A single dispatch method callJavaHeaderScanner
* uses the protocol ID to to dispatch to the appropriate java scanner.
* Uses a separate java specific table: sc_java_header_scanners[]. The
* java scanner is capable of calling the native scan method from java
* but also adds the ability to check all the attached JBinding[] for
* any additional registered bindings. Interesting fact is that if the
* java scanner doesn't have any bindings nor does it override the
* default scan method to perform a scan in java and is also setup to
* dispatch to native scanner, it is exactly same thing as if the
* native scanner was dispatched directly from here, but round
* about way through java land.
*/
if (scanner->sc_scan_table[scan.id] != NULL) {
scanner->sc_scan_table[scan.id](&scan); // Dispatch to scanner
}
#ifdef DEBUG
debug_scan("loop-middle", &scan);
#endif
if (scan.length == 0) {
#ifdef DEBUG
debug_scan("loop-length==0", &scan);
#endif
if (scan.id == PAYLOAD_ID) {
if (scan.stack_index == 0) {
scan.next_id = END_OF_HEADERS;
} else {
scan.stack_index --;
scan.next_id = scan.stack[scan.stack_index].next_id;
scan.offset = scan.stack[scan.stack_index].offset;
}
} else {
scan.next_id = PAYLOAD_ID;
}
} else { // length != 0
#ifdef DEBUG
debug_scan("loop-length > 0", &scan);
#endif
/******************************************************
* ****************************************************
* * If override flag is set, then we reset the
* * discovered next protocol. If that is what the user
* * wants then that is what he gets.
* ****************************************************
******************************************************/
if (scanner->sc_flags[scan.id] & FLAG_OVERRIDE_BINDING) {
#ifdef DEBUG
debug_scan("TCP OVERRIDE", &scan);
#endif
scan.next_id = PAYLOAD_ID;
}
/******************************************************
* ****************************************************
* * Now do HEURISTIC discovery scans if the appropriate
* * flags are set. Heuristics allow us to provide nxt
* * protocol binding, using discovery (an educated
* * guess).
* ****************************************************
******************************************************/
if (scanner->sc_flags[scan.id] & FLAG_HEURISTIC_BINDING) {
/*
* Save these critical properties, in case heuristic changes them
* for this current header, not the next one its supposed to
* check for.
*/
int saved_offset = scan.offset;
int saved_length = scan.length;
/* Advance offset to next header, so that heuristics can get a
* peek. It will be restored at the end of heuristics block.
*/
scan.offset += scan.length + scan.hdr_gap;
/*
* 2 types of heuristic bindings. Pre and post.
* Pre - heuristics are run before the direct discovery method
* in scanner. Only after the pre-heuristic fail do we
* utilize the directly discovered binding.
*
* Post - heuristics are run after the direct discovery method
* didn't produce a binding.
*
* ------------------------------------------------------------
*
* In our case, since we have already ran the direct discovery
* in the header scanner, we save scan.next_id value, reset it,
* call the heuristic function, check its scan.next_id if it
* was set, if it was, then use that instead. Otherwise if it
* wasn't restore the original next_id and continue on normally.
*/
if (scanner->sc_flags[scan.id] & FLAG_HEURISTIC_PRE_BINDING) {
#ifdef DEBUG
debug_scan("heurists_pre", &scan);
#endif
int saved_next_id = scan.next_id;
scan.next_id = PAYLOAD_ID;
for (int i = 0; i < MAX_ID_COUNT; i++) {
native_validate_func_t validate_func;
validate_func
= scanner->sc_heuristics_table[scan.id][i];
if (validate_func == NULL) {
break;
}
if ((scan.next_id = validate_func(&scan)) != INVALID) {
break;
}
}
if (scan.next_id == PAYLOAD_ID) {
scan.next_id = saved_next_id;
}
} else if (scan.next_id == PAYLOAD_ID) {
#ifdef DEBUG
debug_scan("heurists_post", &scan);
#endif
for (int i = 0; i < MAX_ID_COUNT; i++) {
native_validate_func_t validate_func;
validate_func
= scanner->sc_heuristics_table[scan.id][i];
if (validate_func == NULL) {
break;
}
#ifdef DEBUG
debug_trace("heurists_post", "[%d]", i);
#endif
if ((scan.next_id = validate_func(&scan)) != INVALID) {
#ifdef DEBUG
debug_scan("heurists_post::found", &scan);
#endif
break;
}
}
}
/* Restore these 2 critical properties */
scan.offset = saved_offset;
scan.length = saved_length;
}
/******************************************************
* ****************************************************
* * Now record discovered information in structures
* ****************************************************
******************************************************/
record_header(&scan);
#ifdef DEBUG
debug_header("header_t", scan.header - 1);
#endif
} // End if len != 0
#ifdef DEBUG
debug_scan("loop-bottom", &scan);
#endif
scan.id = scan.next_id;
scan.offset += scan.length + scan.hdr_gap;
scan.length = 0;
scan.next_id = PAYLOAD_ID;
if (scan.offset >= scan.buf_len) {
scan.id = END_OF_HEADERS;
}
} // End for loop
/* record number of header entries found */
// scan.packet->pkt_header_count = count;
process_flow_key(&scan);
#ifdef DEBUG
debug_trace("loop-finished",
"header_count=%d offset=%d header_map=0x%X",
scan.packet->pkt_header_count, scan.offset,
scan.packet->pkt_header_map);
debug_exit("scan()");
#endif
return scan.offset;
} // End scan()
/**
* Adjusts for a packet that has been truncated. Sets appropriate flags in the
* header flags field, resets lengths of prefix, header, gap, payload and
* postfix appropriately to account for shortened packet.
*/
void adjustForTruncatedPacket(scan_t *scan) {
#ifdef DEBUG
debug_enter("adjustForTruncatedPacket");
debug_trace("packet", "%ld", scan->scanner->sc_cur_frame_num);
#endif
/*
* Adjust for truncated packets. We check the end of the header record
* against the buf_len. If the end is past the buf_len, that means that we
* need to start trucating in the following order:
* postfix, payload, gap, header, prefix
*
* +-------------------------------------------+
* | prefix | header | gap | payload | postfix |
* +-------------------------------------------+
*
*/
register int start = scan->offset + scan->hdr_prefix + scan->length
+ scan->hdr_gap + scan->hdr_payload;
register int end = start + scan->hdr_postfix;
register int buf_len = scan->buf_len;
#ifdef DEBUG
debug_scan((char *)id2str(scan->id), scan);
debug_trace(id2str(scan->id), "offset=%d, pre=%d, len=%d, gap=%d, pay=%d, post=%d",
scan->offset,
scan->hdr_prefix,
scan->length,
scan->hdr_gap,
scan->hdr_payload,
scan->hdr_postfix);
debug_trace(id2str(scan->id), "start=%d end=%d buf_len=%d", start, end, buf_len);
#endif
if (end > buf_len) { // Check if postfix extends past the end of packet
/*
* Because postfix is at the end, whenever the packet is truncated
* postfix is always truncated, unless it wasn't set
*/
if (scan->hdr_postfix > 0) {
scan->hdr_flags |= HEADER_FLAG_PREFIX_TRUNCATED;
scan->hdr_postfix = (start > scan->mem_len) ? 0 : scan->mem_len
- start;
scan->hdr_postfix = (scan->hdr_postfix < 0) ? 0 : scan->hdr_postfix;
#ifdef DEBUG
debug_scan("adjust postfix", scan);
#endif
}
/* Position at payload and process */
start -= scan->hdr_payload;
end = start + scan->hdr_payload;
if (end > buf_len) {
scan->hdr_flags |= HEADER_FLAG_PAYLOAD_TRUNCATED;
scan->hdr_payload = (start > buf_len) ? 0 : buf_len - start;
scan->hdr_payload = (scan->hdr_payload < 0) ? 0 : scan->hdr_payload;
#ifdef DEBUG
debug_scan("adjust payload", scan);
debug_trace("adjust payload", "start=%d end=%d", start, end);
#endif
/* Position at gap and process */
start -= scan->hdr_gap;
end = start + scan->hdr_gap;
if (scan->hdr_gap > 0 && end > buf_len) {
scan->hdr_flags |= HEADER_FLAG_GAP_TRUNCATED;
scan->hdr_gap = (start > buf_len) ? 0 : buf_len - start;
scan->hdr_gap = (scan->hdr_gap < 0) ? 0 : scan->hdr_gap;
#ifdef DEBUG
debug_scan("adjust gap", scan);
#endif
}
/* Position at header and process */
start -= scan->length;
end = start + scan->length;
if (end > buf_len) {
scan->hdr_flags |= HEADER_FLAG_HEADER_TRUNCATED;
scan->length = (start > buf_len) ? 0 : buf_len - start;
scan->length = (scan->length < 0) ? 0 : scan->length;
#ifdef DEBUG
debug_scan("adjust header", scan);
#endif
/* Position at prefix and process */
start -= scan->hdr_prefix;
end = start + scan->hdr_prefix;
if (0 && scan->hdr_prefix > 0 && end > buf_len) {
scan->hdr_flags |= HEADER_FLAG_PREFIX_TRUNCATED;
scan->hdr_prefix = (start > buf_len) ? 0 : buf_len - start;
scan->hdr_prefix = (scan->hdr_prefix < 0) ? 0
: scan->hdr_prefix;
#ifdef DEBUG
debug_scan("adjust prefix", scan);
#endif
}
}
}
}
#ifdef DEBUG
debug_exit("adjustForTruncatedPacket");
#endif
#undef DEBUG
}
/* scanner specific debug_ trace functions */
void debug_header(char *msg, header_t *header) {
debug_trace(msg,
"id=%s prefix=%-3d header=%-3d gap=%-3d payload=%-3d post=%-3d",
id2str(header->hdr_id), header->hdr_prefix, header->hdr_length,
header->hdr_gap, header->hdr_payload, header->hdr_postfix);
}
void
langdemo(Pool *pool)
{
Id screenid, p, pp;
screenid = str2id(pool, "3ddiag", 1);
static const char *languages[] = {"es", "de"};
pool_set_languages(pool, languages, 2);
FOR_PROVIDES(p, pp, screenid)
{
unsigned int medianr;
Id chktype = 0;
char *loc = solvable_get_location(pool->solvables + p, &medianr);
const char *chksum;
chksum = solvable_lookup_checksum(pool->solvables + p, SOLVABLE_CHECKSUM, &chktype);
printf("%s: %s\n%s[%d] %s:%s\n", solvable2str(pool, pool->solvables + p), solvable_lookup_str_poollang(pool->solvables + p, SOLVABLE_DESCRIPTION), loc, medianr, id2str(pool, chktype), chksum);
printf("DE: %s\n", solvable_lookup_str_lang(pool->solvables + p, SOLVABLE_DESCRIPTION, "de", 1));
}
/** Write out a host's state as JSON data.
* \param h The host object
* \param into ioport to use
*/
int jsoncodec_encode_host (ioport *into, host *h) {
char buffer[256];
uint64_t pathbuffer[128];
int paths = 0;
uint64_t pathmask = 0;
meter *m = h->first;
int i;
int first=1;
int dobrk = 0;
ioport_write (into, "{\n", 2);
while (m) {
pathmask = idhaspath (m->id);
if (pathmask) {
dobrk = 0;
for (i=0; i<paths; ++i) {
if (pathbuffer[i] == (m->id & pathmask)) {
dobrk = 1;
break;
}
}
if (dobrk) {
m = m->next;
continue;
}
if (paths>127) return 1;
pathbuffer[paths++] = (m->id & pathmask);
}
if (first) first=0;
else ioport_write (into, ",\n", 2);
ioport_write (into, " \"", 3);
if (pathmask) {
id2str (m->id & pathmask, buffer);
ioport_write (into, buffer, strlen(buffer));
ioport_write (into, "\":", 2);
if (m->count == SZ_EMPTY_VAL) {
ioport_write (into, "null",4);
}
else if (m->count == SZ_EMPTY_ARRAY) {
ioport_write (into, "[]",2);
}
else {
if (m->count > 0) {
ioport_write (into, "[\n", 2);
}
for (i=0; (i==0)||(i<m->count); ++i) {
if (i) ioport_write (into, ",\n", 2);
jsoncodec_dump_pathval (m,i,into,(m->count ? 1 : 0));
}
if (m->count > 0) {
ioport_write (into, "\n ]", 4);
}
}
}
else {
id2str (m->id, buffer);
ioport_write (into, buffer, strlen(buffer));
ioport_write (into, "\":", 2);
if (m->count == SZ_EMPTY_VAL) {
ioport_write (into, "null", 4);
}
else if (m->count == SZ_EMPTY_ARRAY) {
ioport_write (into, "[]", 2);
}
else {
if (m->count > 0) {
ioport_write (into, "[", 1);
}
for (i=0; (i==0)||(i<m->count); ++i) {
jsoncodec_dump_val (m->id & MMASK_TYPE, m, i, into);
if ((i+1)<m->count) ioport_write (into, ",",1);
}
if (m->count > 0) {
ioport_write (into, "]", 1);
}
}
}
m=m->next;
}
ioport_write (into,"\n}\n",3);
return 0;
}
/** Inspect a host's metering data to determine its current status
* and problems, then write it to disk.
* \param host The host to inspect.
*/
void watchthread_handle_host (host *host) {
int problemcount = 0;
double totalbadness = 0.0;
time_t tnow = time (NULL);
meter *m = host->first;
meterwatch *w;
watchadjust *adj = NULL;
watchtrigger maxtrigger = WATCH_NONE;
char label[16];
char uuidstr[40];
pthread_rwlock_wrlock (&host->lock);
/* We'll store the status information as a meter itself */
meterid_t mid_status = makeid ("status",MTYPE_STR,0);
meter *m_status = host_get_meter (host, mid_status);
fstring ostatus = meter_get_str (m_status, 0);
meter_setcount (m_status, 0);
if (ostatus.str[0] == 0) strcpy (ostatus.str, "UNSET");
/* If the data is stale, don't add to badness, just set the status. */
if ((tnow - host->lastmodified) > 80) {
if (strcmp (ostatus.str, "STALE") != 0) {
uuid2str (host->uuid, uuidstr);
log_info ("Status change host <%s> %s -> STALE", uuidstr, ostatus.str);
tenant_set_notification (host->tenant, true, "STALE", host->uuid);
}
meter_set_str (m_status, 0, "STALE");
}
else {
/* Figure out badness for each meter, and add to host */
while (m) {
m->badness = 0.0;
int handled = 0;
/* Get host-level adjustments in place */
adj = adjustlist_find (&host->adjust, m->id);
/* First go over the tenant-defined watchers */
pthread_mutex_lock (&host->tenant->watch.mutex);
w = host->tenant->watch.first;
while (w) {
if ((w->id & MMASK_NAME) == (m->id & MMASK_NAME)) {
m->badness += calculate_badness (m, w, adj, &maxtrigger);
handled = 1;
}
w = w->next;
}
pthread_mutex_unlock (&host->tenant->watch.mutex);
/* If the tenant didn't have anything suitable, go over the
global watchlist */
if (! handled) {
pthread_mutex_lock (&APP.watch.mutex);
w = APP.watch.first;
while (w) {
if ((w->id & MMASK_NAME) == (m->id & MMASK_NAME)) {
m->badness += calculate_badness (m, w, adj,
&maxtrigger);
handled = 1;
}
w = w->next;
}
pthread_mutex_unlock (&APP.watch.mutex);
}
if (m->badness) problemcount++;
totalbadness += m->badness;
m = m->next;
}
/* Don't raise a CRIT alert on a WARN condition */
switch (maxtrigger) {
case WATCH_NONE:
totalbadness = 0.0;
break;
case WATCH_WARN:
if (host->badness > 50.0) totalbadness = 0.0;
break;
case WATCH_ALERT:
if (host->badness > 90.0) totalbadness = 0.0;
break;
case WATCH_CRIT:
if (host->badness > 150.0) totalbadness = 0.0;
break;
}
host->badness += totalbadness;
/* Put up the problems as a meter as well */
meterid_t mid_problems = makeid ("problems",MTYPE_STR,0);
meter *m_problems = host_get_meter (host, mid_problems);
/* While we're looking at it, consider the current badness, if there
are no problems, it should be going down. */
if (! problemcount) {
if (host->badness > 100.0) host->badness = host->badness/2.0;
else if (host->badness > 1.0) host->badness = host->badness *0.75;
else host->badness = 0.0;
meter_set_empty_array (m_problems);
}
else {
/* If we reached the top, current level may still be out of
its league, so allow it to decay slowly */
if (totalbadness == 0.0) host->badness *= 0.9;
/* Fill in the problem array */
int i=0;
meter_setcount (m_problems, problemcount);
m = host->first;
while (m && (i<16)) {
if (m->badness > 0.00) {
id2str (m->id, label);
meter_set_str (m_problems, i++, label);
}
m = m->next;
}
}
meterid_t mid_badness = makeid ("badness",MTYPE_FRAC,0);
meter *m_badness = host_get_meter (host, mid_badness);
meter_setcount (m_badness, 0);
meter_set_frac (m_badness, 0, host->badness);
const char *nstatus = "UNSET";
/* Convert badness to a status text */
if (host->badness < 30.0) nstatus = "OK";
else if (host->badness < 80.0) nstatus = "WARN";
else if (host->badness < 120.0) nstatus = "ALERT";
else nstatus = "CRIT";
if (strcmp (nstatus, ostatus.str) != 0) {
uuid2str (host->uuid, uuidstr);
log_info ("Status change host <%s> %s -> %s", uuidstr, ostatus.str, nstatus);
bool isproblem = (host->badness>= 80.0);
tenant_set_notification (host->tenant, isproblem, nstatus, host->uuid);
}
meter_set_str (m_status, 0, nstatus);
}
/* Write to db */
if (db_open (APP.writedb, host->tenant->uuid, NULL)) {
db_save_record (APP.writedb, tnow, host);
db_close (APP.writedb);
}
pthread_rwlock_unlock (&host->lock);
/* for tallying the summaries we only need read access */
if (! host->tenant) return;
pthread_rwlock_rdlock (&host->lock);
m = host->first;
while (m) {
summaryinfo_add_meterdata (&host->tenant->summ, m->id, &m->d);
m = m->next;
}
pthread_rwlock_unlock (&host->lock);
}
