static void
vdpau_codec_reinit(media_codec_t *mc)
{
vdpau_codec_t *vc = mc->opaque;
vdpau_dev_t *vd = vc->vc_vd;
vdpau_video_surface_t *vvs;
VdpStatus r;
r = vd->vdp_decoder_create(vd->vd_dev, vc->vc_profile,
vc->vc_width, vc->vc_height,
vc->vc_refframes, &vc->vc_decoder);
if(r != VDP_STATUS_OK) {
TRACE(TRACE_INFO, "VDPAU", "Unable to reinit decoder: %s",
vdpau_errstr(vd, r));
return;
}
TAILQ_FOREACH(vvs, &vc->vc_vvs_free, vvs_link)
vd->vdp_video_surface_create(vd->vd_dev, VDP_CHROMA_TYPE_420,
vc->vc_width, vc->vc_height,
&vvs->vvs_surface);
TAILQ_FOREACH(vvs, &vc->vc_vvs_alloc, vvs_link)
vd->vdp_video_surface_create(vd->vd_dev, VDP_CHROMA_TYPE_420,
vc->vc_width, vc->vc_height,
&vvs->vvs_surface);
}
void
cmd_list_send(struct cmd_list *cmdlist, struct buffer *b)
{
struct cmd *cmd;
u_int n;
n = 0;
TAILQ_FOREACH(cmd, cmdlist, qentry)
n++;
buffer_write(b, &n, sizeof n);
TAILQ_FOREACH(cmd, cmdlist, qentry)
cmd_send(cmd, b);
}
/* Control input callback. Read lines and fire commands. */
void
control_callback(struct client *c, int closed, __unused void *data)
{
char *line, *cause;
struct cmd_list *cmdlist;
struct cmd *cmd;
struct cmdq_item *item;
if (closed)
c->flags |= CLIENT_EXIT;
for (;;) {
line = evbuffer_readln(c->stdin_data, NULL, EVBUFFER_EOL_LF);
if (line == NULL)
break;
if (*line == '\0') { /* empty line exit */
c->flags |= CLIENT_EXIT;
break;
}
if (cmd_string_parse(line, &cmdlist, NULL, 0, &cause) != 0) {
item = cmdq_get_callback(control_error, cause);
cmdq_append(c, item);
} else {
TAILQ_FOREACH(cmd, &cmdlist->list, qentry)
cmd->flags |= CMD_CONTROL;
item = cmdq_get_command(cmdlist, NULL, NULL, 0);
cmdq_append(c, item);
cmd_list_free(cmdlist);
}
free(line);
}
}
void
usb_dump_entries(void)
{
struct usb_blob *pub;
struct usb_device_id *id;
uint32_t x;
id = malloc(usb_blob_count * sizeof(*id));
if (id == NULL)
errx(EX_SOFTWARE, "Out of memory");
/* make linear array of all USB blobs */
x = 0;
TAILQ_FOREACH(pub, &usb_blob_head, entry)
id[x++] = pub->temp;
usb_sort_entries(id, usb_blob_count);
for (x = 0; x != usb_blob_count;)
x += usb_dump(id + x, usb_blob_count - x);
free(id);
printf("# %d USB entries processed\n\n", usb_blob_count);
}
int
cmd_unlink_window_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct args *args = self->args;
struct winlink *wl;
struct window *w;
struct session *s, *s2;
struct session_group *sg;
u_int references;
if ((wl = cmd_find_window(ctx, args_get(args, 't'), &s)) == NULL)
return (-1);
w = wl->window;
sg = session_group_find(s);
if (sg != NULL) {
references = 0;
TAILQ_FOREACH(s2, &sg->sessions, gentry)
references++;
} else
references = 1;
if (!args_has(self->args, 'k') && w->references == references) {
ctx->error(ctx, "window is only linked to one session");
return (-1);
}
server_unlink_window(s, wl);
recalculate_sizes();
return (0);
}
static void Request_parse_postvars(T R)
{
struct evkeyval *val;
char *post = NULL, *rawpost = NULL;
rawpost = g_strndup((char *)EVBUFFER_DATA(R->req->input_buffer), EVBUFFER_LENGTH(R->req->input_buffer));
if (rawpost) {
post = evhttp_decode_uri(rawpost);
g_free(rawpost);
}
R->POST = g_new0(struct evkeyvalq,1);
TAILQ_INIT(R->POST);
if (post) {
int i = 0;
char **p = g_strsplit(post,"&",0);
while (p[i]) {
struct evkeyval *header = g_new0(struct evkeyval,1);
char **kv = g_strsplit(p[i],"=",2);
if (! (kv[0] && kv[1])) break;
header->key = kv[0];
header->value = kv[1];
TAILQ_INSERT_TAIL(R->POST, header, next);
i++;
}
g_strfreev(p);
g_free(post);
}
TAILQ_FOREACH(val, R->POST, next)
TRACE(TRACE_DEBUG,"POST: [%s]->[%s]", val->key, val->value);
}
/**
* Refresh the printer table if needed.
*/
void
refresh_printer_tbl(void)
{
struct printer_entry *entry;
struct printer_entry *entry_tmp;
if (this_tick <= printer_tick) {
HRDBG("no refresh needed");
return;
}
/* mark each entry as missing */
TAILQ_FOREACH(entry, &printer_tbl, link)
entry->flags &= ~HR_PRINTER_FOUND;
hrPrinter_get_OS_entries();
/*
* Purge items that disappeared
*/
entry = TAILQ_FIRST(&printer_tbl);
while (entry != NULL) {
entry_tmp = TAILQ_NEXT(entry, link);
if (!(entry->flags & HR_PRINTER_FOUND))
printer_entry_delete(entry);
entry = entry_tmp;
}
printer_tick = this_tick;
HRDBG("refresh DONE ");
}
void
levent_send_now(struct lldpd *cfg)
{
struct lldpd_hardware *hardware;
TAILQ_FOREACH(hardware, &cfg->g_hardware, h_entries)
event_active(hardware->h_timer, EV_TIMEOUT, 1);
}
static void
satip_device_block( const char *addr, int block )
{
extern const idclass_t satip_device_class;
tvh_hardware_t *th;
satip_device_t *sd;
satip_frontend_t *lfe;
int val = block < 0 ? 0 : block;
pthread_mutex_lock(&global_lock);
TVH_HARDWARE_FOREACH(th) {
if (!idnode_is_instance(&th->th_id, &satip_device_class))
continue;
sd = (satip_device_t *)th;
if (strcmp(sd->sd_info.addr, addr) == 0 && val != sd->sd_dbus_allow) {
sd->sd_dbus_allow = val;
if (block < 0) {
TAILQ_FOREACH(lfe, &sd->sd_frontends, sf_link)
mpegts_input_stop_all((mpegts_input_t *)lfe);
}
tvhinfo("satip", "address %s is %s", addr,
block < 0 ? "stopped" : (block > 0 ? "allowed" : "disabled"));
}
}
pthread_mutex_unlock(&global_lock);
}
static int
reflow_rootward(struct rtb_element *self,
struct rtb_element *instigator, rtb_ev_direction_t direction)
{
struct rtb_element *iter;
struct rtb_size inst_old_size = {
instigator->w,
instigator->h
};
self->layout_cb(self);
/* don't pass the reflow any further rootward if the element's
* size hasn't changed as a result of it. */
if ((instigator->w == inst_old_size.w &&
instigator->h == inst_old_size.h))
return 0;
TAILQ_FOREACH(iter, &self->children, child)
iter->reflow(iter, self, RTB_DIRECTION_LEAFWARD);
if (self->parent)
self->parent->reflow(self->parent, self, direction);
rtb_elem_mark_dirty(self);
return 1;
}
/**
* Refresh the installed software table.
*/
void
refresh_swins_tbl(void)
{
int ret;
struct swins_entry *entry, *entry_tmp;
if (this_tick - swins_tick < swins_tbl_refresh) {
HRDBG("no refresh needed");
return;
}
/* mark each entry as missing */
TAILQ_FOREACH(entry, &swins_tbl, link)
entry->flags &= ~HR_SWINSTALLED_FOUND;
ret = swins_get_packages();
TAILQ_FOREACH_SAFE(entry, &swins_tbl, link, entry_tmp)
if (!(entry->flags & HR_SWINSTALLED_FOUND) &&
!(entry->flags & HR_SWINSTALLED_IMMUTABLE))
swins_entry_delete(entry);
if (ret == 0)
swins_tick = this_tick;
}
/**
* Refresh the hrSWRun and hrSWRunPert tables.
*/
static void
refresh_swrun_tbl(void)
{
struct swrun_entry *entry, *entry_tmp;
if (this_tick - swrun_tick < swrun_tbl_refresh) {
HRDBG("no refresh needed ");
return;
}
/* mark each entry as missing */
TAILQ_FOREACH(entry, &swrun_tbl, link)
entry->flags &= ~HR_SWRUN_FOUND;
swrun_OS_get_procs();
swrun_OS_get_kinfo();
/*
* Purge items that disappeared
*/
TAILQ_FOREACH_SAFE(entry, &swrun_tbl, link, entry_tmp)
if (!(entry->flags & HR_SWRUN_FOUND))
swrun_entry_delete(entry);
swrun_tick = this_tick;
HRDBG("refresh DONE");
}
void
refresh_storage_tbl(int force)
{
struct storage_entry *entry, *entry_tmp;
if (!force && storage_tick != 0 &&
this_tick - storage_tick < storage_tbl_refresh) {
HRDBG("no refresh needed");
return;
}
/* mark each entry as missing */
TAILQ_FOREACH(entry, &storage_tbl, link)
entry->flags &= ~HR_STORAGE_FOUND;
storage_OS_get_vm();
storage_OS_get_swap();
storage_OS_get_fs();
storage_OS_get_memstat();
/*
* Purge items that disappeared
*/
TAILQ_FOREACH_SAFE(entry, &storage_tbl, link, entry_tmp)
if (!(entry->flags & HR_STORAGE_FOUND))
storage_entry_delete(entry);
storage_tick = this_tick;
HRDBG("refresh DONE");
}
static void
FindWindows(AG_Tlist *tl, AG_Window *win, int depth)
{
char text[AG_TLIST_LABEL_MAX];
AG_Window *wSub;
AG_Widget *wChild;
AG_TlistItem *it;
if (strncmp(OBJECT(win)->name, "_Popup-", sizeof("_Popup-")) == 0)
return;
Strlcpy(text, win->caption, sizeof(text));
if (strcmp(OBJECT(win)->name, "generic") == 0) {
it = AG_TlistAddS(tl, NULL,
win->caption[0] != '\0' ? win->caption : _("Untitled"));
} else {
it = AG_TlistAdd(tl, NULL, "%s (<%s>)",
win->caption[0] != '\0' ? win->caption : _("Untitled"),
OBJECT(win)->name);
}
it->p1 = win;
it->depth = depth;
it->cat = "window";
if (!TAILQ_EMPTY(&OBJECT(win)->children) ||
!TAILQ_EMPTY(&win->subwins)) {
it->flags |= AG_TLIST_HAS_CHILDREN;
}
if ((it->flags & AG_TLIST_HAS_CHILDREN) &&
AG_TlistVisibleChildren(tl, it)) {
TAILQ_FOREACH(wSub, &win->subwins, swins)
FindWindows(tl, wSub, depth+1);
OBJECT_FOREACH_CHILD(wChild, win, ag_widget)
FindWidgets(wChild, tl, depth+1);
}
}
static void Request_parse_getvars(T R)
{
struct evkeyval *val;
R->GET = g_new0(struct evkeyvalq,1);
evhttp_parse_query(R->uri, R->GET);
TAILQ_FOREACH(val, R->GET, next)
TRACE(TRACE_DEBUG,"GET: [%s]->[%s]", val->key, val->value);
}
/* Start status timer for all clients. */
void
status_timer_start_all(void)
{
struct client *c;
TAILQ_FOREACH(c, &clients, entry)
status_timer_start(c);
}
void
rtb_elem_draw_children(struct rtb_element *self)
{
struct rtb_element *iter;
TAILQ_FOREACH(iter, &self->children, child)
rtb_elem_draw(iter, 0);
}
static void
api_ipblock_entry_grid
( access_t *perm, idnode_set_t *ins, api_idnode_grid_conf_t *conf, htsmsg_t *args )
{
ipblock_entry_t *ib;
TAILQ_FOREACH(ib, &ipblock_entries, ib_link)
idnode_set_add(ins, (idnode_t*)ib, &conf->filter, perm->aa_lang_ui);
}
static void
api_passwd_entry_grid
( access_t *perm, idnode_set_t *ins, api_idnode_grid_conf_t *conf, htsmsg_t *args )
{
passwd_entry_t *pw;
TAILQ_FOREACH(pw, &passwd_entries, pw_link)
idnode_set_add(ins, (idnode_t*)pw, &conf->filter, perm->aa_lang_ui);
}
static void
api_access_entry_grid
( access_t *perm, idnode_set_t *ins, api_idnode_grid_conf_t *conf, htsmsg_t *args )
{
access_entry_t *ae;
TAILQ_FOREACH(ae, &access_entries, ae_link)
idnode_set_add(ins, (idnode_t*)ae, &conf->filter, perm->aa_lang_ui);
}
static void __inline
count_internal_print(FILE *fout, struct count *count, char *name)
{
struct entry *entry;
int minutes = 0;
int hours = 0;
int day = 0;
TAILQ_FOREACH(entry, &count->seconds, next)
minutes += entry->count;
TAILQ_FOREACH(entry, &count->minutes, next)
hours += entry->count;
TAILQ_FOREACH(entry, &count->hours, next)
day += entry->count;
fprintf(stderr, "%s: %6d %6d %6d\n", name, minutes, hours, day);
}
static void
api_dvr_autorec_grid
( access_t *perm, idnode_set_t *ins, api_idnode_grid_conf_t *conf, htsmsg_t *args )
{
dvr_autorec_entry_t *dae;
TAILQ_FOREACH(dae, &autorec_entries, dae_link)
idnode_set_add(ins, (idnode_t*)dae, &conf->filter);
}
/**
* Called before the refreshing is started from the storage table.
*/
void
fs_tbl_pre_refresh(void)
{
struct fs_entry *entry;
/* mark each entry as missisng */
TAILQ_FOREACH(entry, &fs_tbl, link)
entry->flags &= ~HR_FS_FOUND;
}
static void
api_dvr_timerec_grid
( access_t *perm, idnode_set_t *ins, api_idnode_grid_conf_t *conf, htsmsg_t *args )
{
dvr_timerec_entry_t *dte;
TAILQ_FOREACH(dte, &timerec_entries, dte_link)
idnode_set_add(ins, (idnode_t*)dte, &conf->filter, perm->aa_lang);
}
void
_dl_unload_shlib(elf_object_t *object)
{
struct dep_node *n;
DL_DEB(("unload_shlib called on %s\n", object->load_name));
if (OBJECT_REF_CNT(object) == 0 &&
(object->status & STAT_UNLOADED) == 0) {
object->status |= STAT_UNLOADED;
TAILQ_FOREACH(n, &object->child_list, next_sib)
_dl_unload_shlib(n->data);
TAILQ_FOREACH(n, &object->grpref_list, next_sib)
_dl_unload_shlib(n->data);
DL_DEB(("unload_shlib unloading on %s\n", object->load_name));
_dl_load_list_free(object->load_list);
_dl_munmap((void *)object->load_base, object->load_size);
_dl_remove_object(object);
}
}
/*
* Function name: twa_report
* Description: For being called from ddb. Prints controller stats,
* and requests, if any, that are in the wrong queue.
*
* Input: None
* Output: None
* Return value: None
*/
void
twa_report(void)
{
struct twa_softc *sc;
struct twa_request *tr;
int s;
int i;
s = splcam();
for (i = 0; (sc = devclass_get_softc(twa_devclass, i)) != NULL; i++) {
twa_print_controller(sc);
TAILQ_FOREACH(tr, &sc->twa_busy, tr_link)
twa_print_request(tr, TWA_CMD_BUSY);
TAILQ_FOREACH(tr, &sc->twa_complete, tr_link)
twa_print_request(tr, TWA_CMD_COMPLETE);
}
splx(s);
}
/*
* Print the token list.
*/
static void
toklist_print(struct toklist *tl)
{
struct tok *t;
TAILQ_FOREACH(t, tl, next)
printf("'%s' (Line:%d, Pos:%d, State: %s)\n", t->str, t->lineno, t->pos,
(t->nl == 1) ? "Last (NL)" : "Normal"
);
}
void
pfi_kif_update(struct pfi_kif *kif)
{
struct ifg_list *ifgl;
struct pfi_dynaddr *p;
/* update all dynaddr */
TAILQ_FOREACH(p, &kif->pfik_dynaddrs, entry)
pfi_dynaddr_update(p);
/* again for all groups kif is member of */
if (kif->pfik_ifp != NULL) {
struct ifg_list_head *ifgh = if_get_groups(kif->pfik_ifp);
TAILQ_FOREACH(ifgl, ifgh, ifgl_next)
pfi_kif_update((struct pfi_kif *)
ifgl->ifgl_group->ifg_pf_kif);
}
}
void
xu_ewmh_net_client_list(struct screen_ctx *sc)
{
struct client_ctx *cc;
Window *winlist;
int i = 0, j = 0;
TAILQ_FOREACH(cc, &Clientq, entry)
i++;
if (i == 0)
return;
winlist = xcalloc(i, sizeof(*winlist));
TAILQ_FOREACH(cc, &Clientq, entry)
winlist[j++] = cc->win;
XChangeProperty(X_Dpy, sc->rootwin, ewmh[_NET_CLIENT_LIST],
XA_WINDOW, 32, PropModeReplace, (unsigned char *)winlist, i);
free(winlist);
}
/*
* __session_reset_cursors --
* Reset all open cursors.
*/
static int
__session_reset_cursors(WT_SESSION_IMPL *session)
{
WT_CURSOR *cursor;
WT_DECL_RET;
TAILQ_FOREACH(cursor, &session->cursors, q)
WT_TRET(cursor->reset(cursor));
return (ret);
}
