/** * Retrieves a LinphoneAuthInfo previously entered into the LinphoneCore. **/ const LinphoneAuthInfo *linphone_core_find_auth_info(LinphoneCore *lc, const char *realm, const char *username) { MSList *elem; LinphoneAuthInfo *ret=NULL,*candidate=NULL; for (elem=lc->auth_info;elem!=NULL;elem=elem->next){ LinphoneAuthInfo *pinfo=(LinphoneAuthInfo*)elem->data; if (realm==NULL){ /*return the authinfo for any realm provided that there is only one for that username*/ if (key_match(pinfo->username,username)){ if (ret!=NULL){ ms_warning("There are several auth info for username '%s'",username); return NULL; } ret=pinfo; } }else{ /*return the exact authinfo, or an authinfo for which realm was not supplied yet*/ if (pinfo->realm!=NULL){ if (realm_match(pinfo->realm,realm) && key_match(pinfo->username,username)) ret=pinfo; }else{ if (key_match(pinfo->username,username)) candidate=pinfo; } } } if (ret==NULL && candidate!=NULL) ret=candidate; return ret; }
int Zoltan_Map_Find(ZZ *zz, ZOLTAN_MAP* map, int *key, int *data) { char *yo = "Zoltan_Map_Find"; int index, match; ZOLTAN_ENTRY *element; ZOLTAN_ID_PTR zkey = (ZOLTAN_ID_PTR)key; *data = ZOLTAN_NOT_FOUND; if (!map){ ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Map specified does not exist\n"); return ZOLTAN_FATAL; } index = Zoltan_Hash(zkey, map->id_size, map->max_index); element = map->entries[index]; match = 0; while (element != NULL){ match = key_match(map->id_size, element->key, key); if (match){ *data = element->data; break; } element = element->next; } return ZOLTAN_OK; }
int misc_init_r (void) { char kbd_data[KEYBD_DATALEN]; char keybd_env[2 * KEYBD_DATALEN + 1]; char *str; int i; i2c_init (CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE); i2c_read (CONFIG_SYS_I2C_KEY_ADDR, 0, 0, (uchar *)kbd_data, KEYBD_DATALEN); for (i = 0; i < KEYBD_DATALEN; ++i) { sprintf (keybd_env + i + i, "%02X", kbd_data[i]); } setenv ("keybd", keybd_env); str = strdup ((char *)key_match ((uchar *)keybd_env)); /* decode keys */ #ifdef CONFIG_PREBOOT /* automatically configure "preboot" command on key match */ setenv ("preboot", str); /* set or delete definition */ #endif /* CONFIG_PREBOOT */ if (str != NULL) { free (str); } return (0); }
int misc_init_r(void) { char *s, buf[32]; #ifdef CONFIG_PREBOOT struct kbd_data_t kbd_data; /* Decode keys */ char *str = strdup(key_match(get_keys(&kbd_data))); /* Set or delete definition */ setenv("preboot", str); free(str); #endif /* CONFIG_PREBOOT */ /* count all restarts, and save this in an environment var */ s = getenv("restartcount"); if (s) sprintf(buf, "%ld", simple_strtoul(s, NULL, 10) + 1); else strcpy(buf, "1"); setenv("restartcount", buf); saveenv(); #ifdef CONFIG_HW_WATCHDOG davinci_hw_watchdog_enable(); #endif return 0; }
int board_late_init(void) { #ifdef DELTA_CHECK_KEYBD uchar kbd_data[KEYBD_DATALEN]; char keybd_env[2 * KEYBD_DATALEN + 1]; char *str; int i; #endif /* DELTA_CHECK_KEYBD */ setenv("stdout", "serial"); setenv("stderr", "serial"); #ifdef DELTA_CHECK_KEYBD keys_init(); memset(kbd_data, '\0', KEYBD_DATALEN); /* check for pressed keys and setup keybd_env */ get_pressed_keys(kbd_data); for (i = 0; i < KEYBD_DATALEN; ++i) { sprintf (keybd_env + i + i, "%02X", kbd_data[i]); } setenv ("keybd", keybd_env); str = strdup ((char *)key_match (kbd_data)); /* decode keys */ # ifdef CONFIG_PREBOOT /* automatically configure "preboot" command on key match */ setenv ("preboot", str); /* set or delete definition */ # endif /* CONFIG_PREBOOT */ if (str != NULL) { free (str); } #endif /* DELTA_CHECK_KEYBD */ init_DA9030(); return 0; }
/* * This function interprets the reply and prints it to stdout. It returns * 0 if no more should be read and 1 to indicate that more messages of this * type may need to be read. */ int audit_print_reply(struct audit_reply *rep, int fd) { _audit_elf = 0; switch (rep->type) { case NLMSG_NOOP: return 1; case NLMSG_DONE: // Close the socket so kernel can do other things audit_close(fd); if (printed == 0) printf("No rules\n"); else { lnode *n; list_first(&l); n = l.cur; while (n) { print_rule(n->r); n = list_next(&l); } list_clear(&l); } break; case NLMSG_ERROR: printf("NLMSG_ERROR %d (%s)\n", -rep->error->error, strerror(-rep->error->error)); printed = 1; break; case AUDIT_GET: if (interpret) printf("enabled %s\nfailure %s\n", get_enable(rep->status->enabled), get_failure(rep->status->failure)); else printf("enabled %u\nfailure %u\n", rep->status->enabled, rep->status->failure); printf("pid %u\nrate_limit %u\nbacklog_limit %u\n" "lost %u\nbacklog %u\n", rep->status->pid, rep->status->rate_limit, rep->status->backlog_limit, rep->status->lost, rep->status->backlog); #if HAVE_DECL_AUDIT_VERSION_BACKLOG_WAIT_TIME printf("backlog_wait_time %u\n", rep->status->backlog_wait_time); #endif printed = 1; break; #if HAVE_DECL_AUDIT_FEATURE_VERSION case AUDIT_GET_FEATURE: { uint32_t mask = AUDIT_FEATURE_TO_MASK(AUDIT_FEATURE_LOGINUID_IMMUTABLE); if (rep->features->mask & mask) printf("loginuid_immutable %u %s\n", !!(rep->features->features & mask), rep->features->lock & mask ? "locked" : "unlocked"); } printed = 1; break; #endif case AUDIT_LIST_RULES: list_requested = 0; if (key_match(rep->ruledata)) list_append(&l, rep->ruledata, sizeof(struct audit_rule_data) + rep->ruledata->buflen); printed = 1; return 1; default: printf("Unknown: type=%d, len=%d\n", rep->type, rep->nlh->nlmsg_len); printed = 1; break; } return 0; }
int Zoltan_Map_Find_Add(ZZ *zz, ZOLTAN_MAP* map, int *key, int datain, int *dataout) { char *yo = "Zoltan_Map_Add"; int index, match, i; ZOLTAN_ENTRY *element; ZOLTAN_ID_PTR zkey = (ZOLTAN_ID_PTR)key; if (!map){ ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Map specified does not exist\n"); return ZOLTAN_FATAL; } index = Zoltan_Hash(zkey, map->id_size, map->max_index); /* If this key is not found in the map, then add it */ element = map->entries[index]; match = 0; while (element != NULL){ match = key_match(map->id_size, element->key, key); if (match){ break; } element = element->next; } if (!match){ i = map->entry_count; if (!map->dynamicEntries && (i == map->max_entries)){ ZOLTAN_PRINT_ERROR(zz->Proc, yo, "Fixed size map overflow\n"); return ZOLTAN_FATAL; } if (map->dynamicEntries){ element = (ZOLTAN_ENTRY *)ZOLTAN_MALLOC(sizeof(ZOLTAN_ENTRY)); if (!element) return ZOLTAN_MEMERR; } else{ element = map->top + i; } if (map->copyKeys){ if(map->dynamicEntries) { element->key = (int *)ZOLTAN_MALLOC(sizeof(int) * map->id_size); if (!element->key) return ZOLTAN_MEMERR; } else element->key = map->keys + map->entry_count; memcpy(element->key, key, sizeof(int)*map->id_size); } else{ element->key = key; } element->data = datain; element->next = map->entries[index]; map->entries[index] = element; map->entry_count++; } if (dataout != NULL) { *dataout = element->data; } return ZOLTAN_OK; }
/* * This function interprets the reply and prints it to stdout. It returns * 0 if no more should be read and 1 to indicate that more messages of this * type may need to be read. */ static int audit_print_reply(struct audit_reply *rep) { unsigned int i; int first; int sparse; int machine = audit_detect_machine(); size_t boffset; int show_syscall; _audit_elf = 0; switch (rep->type) { case NLMSG_NOOP: return 1; case NLMSG_DONE: if (printed == 0) printf("No rules\n"); return 0; case NLMSG_ERROR: printf("NLMSG_ERROR %d (%s)\n", -rep->error->error, strerror(-rep->error->error)); printed = 1; return 0; case AUDIT_GET: printf("AUDIT_STATUS: enabled=%d flag=%d pid=%d" " rate_limit=%d backlog_limit=%d lost=%d backlog=%u\n", rep->status->enabled, rep->status->failure, rep->status->pid, rep->status->rate_limit, rep->status->backlog_limit, rep->status->lost, rep->status->backlog); printed = 1; return 0; case AUDIT_LIST_RULES: list_requested = 0; boffset = 0; show_syscall = 1; if (key_match(rep) == 0) return 1; printed = 1; printf("%s: %s,%s", audit_msg_type_to_name(rep->type), audit_flag_to_name((int)rep->ruledata->flags), audit_action_to_name(rep->ruledata->action)); for (i = 0; i < rep->ruledata->field_count; i++) { const char *name; int op = rep->ruledata->fieldflags[i] & AUDIT_OPERATORS; int field = rep->ruledata->fields[i] & ~AUDIT_OPERATORS; name = audit_field_to_name(field); if (name) { if (strcmp(name, "arch") == 0) { _audit_elf = rep->ruledata->values[i]; printf(" %s%s%u", name, audit_operator_to_symbol(op), (unsigned)rep->ruledata->values[i]); } else if (strcmp(name, "msgtype") == 0) { if (!audit_msg_type_to_name( rep->ruledata->values[i])) printf(" %s%s%d", name, audit_operator_to_symbol(op), rep->ruledata->values[i]); else { printf(" %s%s%s", name, audit_operator_to_symbol(op), audit_msg_type_to_name(rep->ruledata->values[i])); } } else if ((field >= AUDIT_SUBJ_USER && field <= AUDIT_OBJ_LEV_HIGH) && field != AUDIT_PPID && rep->type == AUDIT_LIST_RULES) { printf(" %s%s%.*s", name, audit_operator_to_symbol(op), rep->ruledata->values[i], &rep->ruledata->buf[boffset]); boffset += rep->ruledata->values[i]; } else if (field == AUDIT_WATCH) { printf(" watch=%.*s", rep->ruledata->values[i], &rep->ruledata->buf[boffset]); boffset += rep->ruledata->values[i]; } else if (field == AUDIT_DIR) { printf(" dir=%.*s", rep->ruledata->values[i], &rep->ruledata->buf[boffset]); boffset += rep->ruledata->values[i]; } else if (field == AUDIT_FILTERKEY) { char *rkey, *ptr; asprintf(&rkey, "%.*s", rep->ruledata->values[i], &rep->ruledata->buf[boffset]); boffset += rep->ruledata->values[i]; ptr = strtok(rkey, key_sep); while (ptr) { printf(" key=%s", ptr); ptr = strtok(NULL, key_sep); } free(rkey); } else if (field == AUDIT_PERM) { char perms[5]; int val=rep->ruledata->values[i]; perms[0] = 0; if (val & AUDIT_PERM_READ) strcat(perms, "r"); if (val & AUDIT_PERM_WRITE) strcat(perms, "w"); if (val & AUDIT_PERM_EXEC) strcat(perms, "x"); if (val & AUDIT_PERM_ATTR) strcat(perms, "a"); printf(" perm=%s", perms); show_syscall = 0; } else if (field == AUDIT_INODE) { // Unsigned items printf(" %s%s%u", name, audit_operator_to_symbol(op), rep->ruledata->values[i]); } else if (field == AUDIT_FIELD_COMPARE) { switch (rep->ruledata->values[i]) { case AUDIT_COMPARE_UID_TO_OBJ_UID: printf(" uid%sobj_uid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_GID_TO_OBJ_GID: printf(" gid%sobj_gid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_EUID_TO_OBJ_UID: printf(" euid%sobj_uid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_EGID_TO_OBJ_GID: printf(" egid%sobj_gid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_AUID_TO_OBJ_UID: printf(" auid%sobj_uid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_SUID_TO_OBJ_UID: printf(" suid%sobj_uid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_SGID_TO_OBJ_GID: printf(" sgid%sobj_gid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_FSUID_TO_OBJ_UID: printf(" fsuid%sobj_uid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_FSGID_TO_OBJ_GID: printf(" fsgid%sobj_gid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_UID_TO_AUID: printf(" uid%sauid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_UID_TO_EUID: printf(" uid%seuid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_UID_TO_FSUID: printf(" uid%sfsuid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_UID_TO_SUID: printf(" uid%ssuid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_AUID_TO_FSUID: printf(" auid%sfsuid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_AUID_TO_SUID: printf(" auid%ssuid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_AUID_TO_EUID: printf(" auid%seuid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_EUID_TO_SUID: printf(" euid%ssuid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_EUID_TO_FSUID: printf(" euid%sfsuid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_SUID_TO_FSUID: printf(" suid%sfsuid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_GID_TO_EGID: printf(" gid%segid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_GID_TO_FSGID: printf(" gid%sfsgid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_GID_TO_SGID: printf(" gid%ssgid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_EGID_TO_FSGID: printf(" egid%sfsgid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_EGID_TO_SGID: printf(" egid%ssgid",audit_operator_to_symbol(op)); break; case AUDIT_COMPARE_SGID_TO_FSGID: printf(" sgid%sfsgid",audit_operator_to_symbol(op)); break; } } else { // Signed items printf(" %s%s%d", name, audit_operator_to_symbol(op), rep->ruledata->values[i]); } } else { printf(" f%d%s%d", rep->ruledata->fields[i], audit_operator_to_symbol(op), rep->ruledata->values[i]); } /* Avoid printing value if the field type is * known to return a string. */ if (rep->ruledata->values[i] && (field < AUDIT_SUBJ_USER || field > AUDIT_SUBJ_CLR) && field != AUDIT_WATCH && field != AUDIT_FILTERKEY && field != AUDIT_PERM && field != AUDIT_FIELD_COMPARE) printf(" (0x%x)", rep->ruledata->values[i]); } if (show_syscall && ((rep->ruledata->flags & AUDIT_FILTER_MASK) != AUDIT_FILTER_USER) && ((rep->ruledata->flags & AUDIT_FILTER_MASK) != AUDIT_FILTER_TASK) && ((rep->ruledata->flags & AUDIT_FILTER_MASK) != AUDIT_FILTER_EXCLUDE)) { printf(" syscall="); for (sparse = 0, i = 0; i < (AUDIT_BITMASK_SIZE-1); i++) { if (rep->ruledata->mask[i] != (uint32_t)~0) sparse = 1; } if (!sparse) { printf("all"); } else for (first = 1, i = 0; i < AUDIT_BITMASK_SIZE * 32; i++) { int word = AUDIT_WORD(i); int bit = AUDIT_BIT(i); if (rep->ruledata->mask[word] & bit) { const char *ptr; if (_audit_elf) machine = audit_elf_to_machine( _audit_elf); if (machine < 0) ptr = NULL; else ptr = audit_syscall_to_name(i, machine); if (ptr) printf("%s%s", first ? "" : ",", ptr); else printf("%s%d", first ? "" : ",", i); first = 0; } } } printf("\n"); return 1; /* get more messages until NLMSG_DONE */ default: printf("Unknown: type=%d, len=%d\n", rep->type, rep->nlh->nlmsg_len); printed = 1; return 0; } }
/*********************************************************************** F* Function: int misc_init_r (void) P*A*Z* * P* Parameters: none P* P* Returnvalue: int P* - 0 is always returned, even in the case of a keyboard P* error. * Z* Intention: This function is the misc_init_r() method implementation Z* for the lwmon board. Z* The keyboard controller is initialized and the result Z* of a read copied to the environment variable "keybd". Z* If KEYBD_SET_DEBUGMODE is defined, a check is made for Z* this key, and if found display to the LCD will be enabled. Z* The keys in "keybd" are checked against the magic Z* keycommands defined in the environment. Z* See also key_match(). * D* Design: [email protected] C* Coding: [email protected] V* Verification: [email protected] ***********************************************************************/ int misc_init_r_kbd (void) { uchar kbd_data[KEYBD_DATALEN]; char keybd_env[2 * KEYBD_DATALEN + 1]; uchar kbd_init_status = gd->arch.kbd_status >> 8; uchar kbd_status = gd->arch.kbd_status; uchar val; ushort data, inv_data; char *str; int i; if (kbd_init_status) { printf ("KEYBD: Error %02X\n", kbd_init_status); } if (kbd_status) { /* permanent error, report it */ printf ("*** Keyboard error code %02X ***\n", kbd_status); sprintf (keybd_env, "%02X", kbd_status); setenv ("keybd", keybd_env); return 0; } /* * Now we know that we have a working keyboard, so disable * all output to the LCD except when a key press is detected. */ if ((console_assign (stdout, "serial") < 0) || (console_assign (stderr, "serial") < 0)) { printf ("Can't assign serial port as output device\n"); } /* Read Version */ val = KEYBD_CMD_READ_VERSION; i2c_write (kbd_addr, 0, 0, &val, 1); i2c_read (kbd_addr, 0, 0, kbd_data, KEYBD_VERSIONLEN); printf ("KEYBD: Version %d.%d\n", kbd_data[0], kbd_data[1]); /* Read current keyboard state */ val = KEYBD_CMD_READ_KEYS; i2c_write (kbd_addr, 0, 0, &val, 1); i2c_read (kbd_addr, 0, 0, kbd_data, KEYBD_DATALEN); /* read out start key from bse01 received via can */ _dspic_read(DSPIC_PON_STATUS_REG, &data); /* check highbyte from status register */ if (data > 0xFF) { _dspic_read(DSPIC_PON_INV_STATUS_REG, &inv_data); /* check inverse data */ if ((data+inv_data) == 0xFFFF) { /* don't overwrite local key */ if (kbd_data[1] == 0) { /* read key value */ _dspic_read(DSPIC_PON_KEY_REG, &data); str = (char *)&data; /* swap bytes */ kbd_data[1] = str[1]; kbd_data[2] = str[0]; printf("CAN received startkey: 0x%X\n", data); } } } for (i = 0; i < KEYBD_DATALEN; ++i) { sprintf (keybd_env + i + i, "%02X", kbd_data[i]); } setenv ("keybd", keybd_env); str = strdup ((char *)key_match (kbd_data)); /* decode keys */ #ifdef KEYBD_SET_DEBUGMODE if (kbd_data[0] == KEYBD_SET_DEBUGMODE) { /* set debug mode */ if ((console_assign (stdout, "lcd") < 0) || (console_assign (stderr, "lcd") < 0)) { printf ("Can't assign LCD display as output device\n"); } } #endif /* KEYBD_SET_DEBUGMODE */ #ifdef CONFIG_PREBOOT /* automatically configure "preboot" command on key match */ setenv ("preboot", str); /* set or delete definition */ #endif /* CONFIG_PREBOOT */ if (str != NULL) { free (str); } return (0); }
/*********************************************************************** F* Function: int misc_init_r (void) P*A*Z* * P* Parameters: none P* P* Returnvalue: int P* - 0 is always returned, even in the case of a keyboard P* error. * Z* Intention: This function is the misc_init_r() method implementation Z* for the lwmon board. Z* The keyboard controller is initialized and the result Z* of a read copied to the environment variable "keybd". Z* If KEYBD_SET_DEBUGMODE is defined, a check is made for Z* this key, and if found display to the LCD will be enabled. Z* The keys in "keybd" are checked against the magic Z* keycommands defined in the environment. Z* See also key_match(). * D* Design: [email protected] C* Coding: [email protected] V* Verification: [email protected] ***********************************************************************/ int misc_init_r_kbd (void) { uchar kbd_data[KEYBD_DATALEN]; char keybd_env[2 * KEYBD_DATALEN + 1]; uchar kbd_init_status = gd->kbd_status >> 8; uchar kbd_status = gd->kbd_status; uchar val; char *str; int i; if (kbd_init_status) { printf ("KEYBD: Error %02X\n", kbd_init_status); } if (kbd_status) { /* permanent error, report it */ printf ("*** Keyboard error code %02X ***\n", kbd_status); sprintf (keybd_env, "%02X", kbd_status); setenv ("keybd", keybd_env); return 0; } /* * Now we know that we have a working keyboard, so disable * all output to the LCD except when a key press is detected. */ if ((console_assign (stdout, "serial") < 0) || (console_assign (stderr, "serial") < 0)) { printf ("Can't assign serial port as output device\n"); } /* Read Version */ val = KEYBD_CMD_READ_VERSION; i2c_write (kbd_addr, 0, 0, &val, 1); i2c_read (kbd_addr, 0, 0, kbd_data, KEYBD_VERSIONLEN); printf ("KEYBD: Version %d.%d\n", kbd_data[0], kbd_data[1]); /* Read current keyboard state */ val = KEYBD_CMD_READ_KEYS; i2c_write (kbd_addr, 0, 0, &val, 1); i2c_read (kbd_addr, 0, 0, kbd_data, KEYBD_DATALEN); for (i = 0; i < KEYBD_DATALEN; ++i) { sprintf (keybd_env + i + i, "%02X", kbd_data[i]); } setenv ("keybd", keybd_env); str = strdup ((char *)key_match (kbd_data)); /* decode keys */ #ifdef KEYBD_SET_DEBUGMODE if (kbd_data[0] == KEYBD_SET_DEBUGMODE) { /* set debug mode */ if ((console_assign (stdout, "lcd") < 0) || (console_assign (stderr, "lcd") < 0)) { printf ("Can't assign LCD display as output device\n"); } } #endif /* KEYBD_SET_DEBUGMODE */ #ifdef CONFIG_PREBOOT /* automatically configure "preboot" command on key match */ setenv ("preboot", str); /* set or delete definition */ #endif /* CONFIG_PREBOOT */ if (str != NULL) { free (str); } return (0); }