kw
char *kw;
kw = "Function";
kw = "Data";
seterrline(Curline, meta_info.mi_filename, kw, value);
"Error: Missing argument in \"%s\" line", kw);
char *kw;
kw = "Function";
kw = "Data";
seterrline(LINE, m.mi_filename, kw, value);
"missing argument in \"%s\" line", kw);
remque(&kw->kw_links);
free(kw);
kw_t *kw;
for (kw = (kw_t *)kw_list.q_forw;
kw != (kw_t *)&kw_list;
kw = (kw_t *)kw->kw_links.q_forw) {
if (strcmp(essid, kw->kw_essid) == 0)
return (kw);
kw_t *kw;
if ((kw = calloc(1, sizeof (kw_t))) == NULL) {
kw->kw_bssids.q_forw = kw->kw_bssids.q_back = &kw->kw_bssids;
(void) strlcpy(kw->kw_essid, essid, sizeof (kw->kw_essid));
kw->kw_num_bssids = 1;
insque(&b->bssid_links, kw->kw_bssids.q_back);
insque(&kw->kw_links, kw_list.q_back);
kw_update(kw_t *kw, const char *bssid)
insque(&b->bssid_links, kw->kw_bssids.q_back);
kw->kw_num_bssids++;
remque(&kw->kw_links);
insque(&kw->kw_links, kw_list.q_back);
bssid, kw->kw_essid);
kw_t *kw;
if ((kw = kw_lookup(tok[ESSID])) == NULL) {
if (!kw_update(kw, tok[BSSID])) {
kw_t *kw;
for (kw = (kw_t *)kw_list.q_forw, priority = num_kw-1;
kw != (kw_t *)&kw_list;
kw = (kw_t *)kw->kw_links.q_forw, priority--) {
nlog(LOG_DEBUG, "Creating Known WLAN %s", kw->kw_essid);
if ((err = nwam_known_wlan_create(kw->kw_essid, &kwh))
"could not create known wlan: %s", kw->kw_essid,
"could not create priority value: %s", kw->kw_essid,
"could not set priority value: %s", kw->kw_essid,
bssids = calloc(kw->kw_num_bssids, sizeof (char *));
"could not calloc for bssids: %m", kw->kw_essid);
for (b = (bssid_t *)kw->kw_bssids.q_forw, i = 0;
b != (bssid_t *)&kw->kw_bssids;
kw->kw_num_bssids, &bssidsval)) != NWAM_SUCCESS) {
"could not create bssids value: %s", kw->kw_essid,
for (i = 0; i < kw->kw_num_bssids; i++)
for (i = 0; i < kw->kw_num_bssids; i++)
"could not set bssids: %s", kw->kw_essid,
nwamd_set_key_name(kw->kw_essid, NULL, nsa.nsa_essid_prefix,
kw->kw_essid, nwam_strerror(err));
"could not commit wlan: %s", kw->kw_essid,
kw_t *kw;
kw = (kw_t *)kw_list.q_forw;
while (kw->kw_bssids.q_forw != &kw->kw_bssids) {
b = (bssid_t *)kw->kw_bssids.q_forw;
add_order_bit(int kw)
switch (kw) {
struct fn *kw = fn_new(NULL);
fn_renew(kw, NULL);
fn_putc(kw, c);
fn_putc(kw, fn_getc(src));
fn_s(kw))) == NULL) {
fn_putfn(dst, kw);
fn_free(kw);
uint_t d = 0, kd = 0, w = 0, kw = 0;
kw++; /* count common walkers */
modinfo.mi_walkers = mdb_zalloc(sizeof (*wp) * (w + kw + 1), UM_SLEEP);
(modinfo.mi_walkers + w), sizeof (*wp) * kw);
kmemlog_walk_t *kw;
kw = mdb_zalloc(sizeof (kmemlog_walk_t), UM_SLEEP);
kw->kmlw_entries = mdb_zalloc(sym.st_size, UM_SLEEP);
kw->kmlw_addr = sym.st_value;
if (mdb_vread(kw->kmlw_entries, sym.st_size, sym.st_value) == -1) {
mdb_free(kw->kmlw_entries, sym.st_size);
mdb_free(kw, sizeof (kmemlog_walk_t));
kw->kmlw_nentries = sym.st_size / sizeof (mm_logentry_t);
mdb_readvar(&kw->kmlw_entry, "mm_kmemlogent");
kw->kmlw_oldest = kw->kmlw_entry;
wsp->walk_data = kw;
kmemlog_walk_t *kw = wsp->walk_data;
ent = &kw->kmlw_entries[kw->kmlw_entry];
if (++kw->kmlw_entry == kw->kmlw_nentries)
kw->kmlw_entry = 0;
rval = wsp->walk_callback(kw->kmlw_addr + ((uintptr_t)ent -
(uintptr_t)kw->kmlw_entries), ent, wsp->walk_cbdata);
if (rval == WALK_NEXT && kw->kmlw_entry == kw->kmlw_oldest)
kmemlog_walk_t *kw = wsp->walk_data;
mdb_free(kw->kmlw_entries, kw->kmlw_nentries * sizeof (mm_logentry_t));
mdb_free(kw, sizeof (kmemlog_walk_t));
uint64_t kw[WCNT + 4 + RCNT * 2];
uint64_t kw[WCNT + 4]; /* key schedule words : chaining vars + tweak */
#define ks (kw + KW_KEY_BASE)
#define ts (kw + KW_TWK_BASE)
uint64_t kw[WCNT + 4 + RCNT * 2];
uint64_t kw[WCNT + 4]; /* key schedule words : chaining vars + tweak */
uint64_t kw[WCNT + 4 + RCNT * 2];
uint64_t kw[WCNT + 4]; /* key schedule words : chaining vars + tweak */
struct keyword_desc *kw, *nextkw;
for (kw = matching_keywords; kw->value != NULL; kw++) {
if (strncmp(*rule, kw->value, kw->length) == 0) {
kw_type = kw->kwtype;
kwval_type = kw->kwvaltype;
*rule += kw->length;
*remaining -= kw->length;
if (kw->value == NULL) {
pkiDebug("%s: found keyword '%s'\n", __FUNCTION__, kw->value);
__FUNCTION__, kw->value);
if (kw->kwvaltype == kwvaltype_regexp) {
} else if (kw->kwvaltype == kwvaltype_list) {
__FUNCTION__, retval, kw->value);
keyword2string(unsigned int kw)
switch(kw) {
if (!sym->kw)
if (sym->kw->token != BASIC_TYPE)
ti->size_fixed_part = sym->kw->value;
ndr_keyword_t *kw;
kw = &kwtable[i];
sym = sym_enter(kw->name);
sym->kw = kw;
if (sym->kw) {
return (sym->kw->token);
return (sym->kw->token);
return (sym->kw->token);
ndr_keyword_t *kw;
int get_vpd_keyword_val(const struct t4_vpd_hdr *v, const char *kw)
if(memcmp(buf + i , kw , 2) == 0){
ksyms_walkinfo_t kw;
(void) ksyms_walk(&kw, NULL, 0, NULL, NULL,
shp->sh_offset = kw.kw_size[KW_HEADER];
shp->sh_size = kw.kw_size[KW_LOCALS] + kw.kw_size[KW_GLOBALS];
shp->sh_info = kw.kw_size[KW_LOCALS] / sizeof (Sym);
shp->sh_offset = kw.kw_size[KW_HEADER] +
kw.kw_size[KW_LOCALS] + kw.kw_size[KW_GLOBALS];
shp->sh_size = kw.kw_size[KW_STRINGS];
size += ksyms_walk(&kw, buf, (bufsize - size), emit, &hdr,
size += ksyms_walk(&kw, buf, (bufsize - size), emit,
size += ksyms_walk(&kw, buf, (bufsize - size), emit,
size += ksyms_walk(&kw, buf, (bufsize - size), emit, NULL,