/usr/src/lib/libkeynote/environment.c

Bug Summary

File:	src/lib/libkeynote/environment.c
Warning:	line 173, column 7 Called function pointer is null (null dereference)

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name environment.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/lib/libkeynote/obj -resource-dir /usr/local/lib/clang/13.0.0 -I . -I /usr/src/lib/libkeynote -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/lib/libkeynote/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/lib/libkeynote/environment.c

1/* $OpenBSD: environment.c,v 1.29 2015/12/23 20:28:15 mmcc Exp $ */
2/*
* The author of this code is Angelos D. Keromytis (angelos@dsl.cis.upenn.edu)
*
* This code was written by Angelos D. Keromytis in Philadelphia, PA, USA,
* in April-May 1998
*
* Copyright (C) 1998, 1999 by Angelos D. Keromytis.
*	
* Permission to use, copy, and modify this software with or without fee
* is hereby granted, provided that this entire notice is included in
* all copies of any software which is or includes a copy or
* modification of this software. 
*
* THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTY. IN PARTICULAR, THE AUTHORS MAKES NO
* REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE
* MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*/


23#include <sys/types.h>

25#include <ctype.h>
26#include <fcntl.h>
27#include <regex.h>
28#include <stdlib.h>
29#include <stdio.h>
30#include <string.h>
31#include <unistd.h>

33#include "keynote.h"
34#include "assertion.h"

36static int sessioncounter = 0;

38char **keynote_values = NULL((void *)0);
39char *keynote_privkey = NULL((void *)0);

41struct assertion *keynote_current_assertion = NULL((void *)0);

43struct environment *keynote_init_list = NULL((void *)0);
44struct environment *keynote_temp_list = NULL((void *)0);

46struct keylist *keynote_keypred_keylist = NULL((void *)0);

48struct keynote_session *keynote_sessions[SESSIONTABLESIZE37];
49struct keynote_session *keynote_current_session = NULL((void *)0);

51int keynote_exceptionflag = 0;
52int keynote_used_variable = 0;
53int keynote_returnvalue = 0;
54int keynote_justrecord = 0;
55int keynote_donteval = 0;
56int keynote_errno = 0;

58/*
* Construct the _ACTION_AUTHORIZERS variable value.
*/
61static char *
62keynote_get_action_authorizers(char *name)
63{
  struct keylist *kl;
  size_t cachesize;
  int len;

  if (!strcmp(name, KEYNOTE_CALLBACK_CLEANUP"_KEYNOTE_CALLBACK_CLEANUP") ||
      !strcmp(name, KEYNOTE_CALLBACK_INITIALIZE"_KEYNOTE_CALLBACK_INITIALIZE"))
  {
      free(keynote_current_session->ks_authorizers_cache);
      keynote_current_session->ks_authorizers_cache = NULL((void *)0);

return "";
  }

  if (keynote_current_session->ks_authorizers_cache != NULL((void *)0))
    return keynote_current_session->ks_authorizers_cache;

  for (cachesize = 0, kl = keynote_current_session->ks_action_authorizers;
kl != NULL((void *)0);
kl = kl->key_next)
    if (kl->key_stringkey != NULL((void *)0))
      cachesize += strlen(kl->key_stringkey) + 1;

  if (cachesize == 0)
    return "";

  keynote_current_session->ks_authorizers_cache =
calloc(cachesize, sizeof(char));
  if (keynote_current_session->ks_authorizers_cache == NULL((void *)0)) {
keynote_errno = ERROR_MEMORY-1;
return NULL((void *)0);
  }

  for (len = 0, kl = keynote_current_session->ks_action_authorizers;
kl != NULL((void *)0);
kl = kl->key_next)
    if (kl->key_stringkey != NULL((void *)0)) {
 snprintf(keynote_current_session->ks_authorizers_cache + len,
   cachesize - len, "%s,", kl->key_stringkey);
 len += strlen(kl->key_stringkey) + 1;
    }

  keynote_current_session->ks_authorizers_cache[len - 1] = '\0';
  return keynote_current_session->ks_authorizers_cache;
107}

109/*
* Construct the _VALUES variable value.
*/
112static char *
113keynote_get_values(char *name)
114{
  int i, len;
  size_t cachesize;

  if (!strcmp(name, KEYNOTE_CALLBACK_CLEANUP"_KEYNOTE_CALLBACK_CLEANUP") ||
      !strcmp(name, KEYNOTE_CALLBACK_INITIALIZE"_KEYNOTE_CALLBACK_INITIALIZE"))
  {
      free(keynote_current_session->ks_values_cache);
      keynote_current_session->ks_values_cache = NULL((void *)0);

return "";
  }

  if (keynote_current_session->ks_values_cache != NULL((void *)0))
    return keynote_current_session->ks_values_cache;

  for (cachesize = 0, i = 0; i < keynote_current_session->ks_values_num; i++)
    cachesize += strlen(keynote_current_session->ks_values[i]) + 1;

  if (cachesize == 0)
    return "";

  keynote_current_session->ks_values_cache =
calloc(cachesize, sizeof(char));
  if (keynote_current_session->ks_values_cache == NULL((void *)0)) {
keynote_errno = ERROR_MEMORY-1;
return NULL((void *)0);
  }

  for (len = 0, i = 0; i < keynote_current_session->ks_values_num; i++)
  {
snprintf(keynote_current_session->ks_values_cache + len,
 cachesize - len, "%s,", keynote_current_session->ks_values[i]);
len += strlen(keynote_current_session->ks_values[i]) + 1;
  }

  keynote_current_session->ks_values_cache[len - 1] = '\0';
  return keynote_current_session->ks_values_cache;
152}

154/*
* Free an environment structure.
*/
157void
158keynote_free_env(struct environment *en)
159{
  if (en26.1
'en' is not equal to NULL
 == NULL((void *)0))
27
←
Taking false branch→
    return;

  free(en->env_name);

  if (en->env_flags & ENVIRONMENT_FLAG_REGEX0x0002)
28
←
Assuming the condition is false→
29
←
Taking false branch→
    regfree(&(en->env_regex));

  if (!(en->env_flags & ENVIRONMENT_FLAG_FUNC0x0001))
30
←
Assuming the condition is false→
31
←
Taking false branch→
  {
      free(en->env_value);
  }
  else
    ((char * (*) (char *))en->env_value)(KEYNOTE_CALLBACK_CLEANUP"_KEYNOTE_CALLBACK_CLEANUP");
32
←
Called function pointer is null (null dereference)

  free(en);
176}

178/*
* Lookup for variable "name" in the hash table. If hashsize is 1,
* then the second argument is actually a pointer to a list. Last
* argument specifies case-insensitivity.
*/
183char *
184keynote_env_lookup(char *name, struct environment **table,
                 unsigned int hashsize)
186{
  struct environment *en;

  for (en = table[keynote_stringhash(name, hashsize)]; 
en != NULL((void *)0);
en = en->env_next)
    if (((en->env_flags & ENVIRONMENT_FLAG_REGEX0x0002) &&
  (regexec(&(en->env_regex), name, 0, NULL((void *)0), 0) == 0)) ||
   (!strcmp(name, en->env_name)))
    {
 if ((en->env_flags & ENVIRONMENT_FLAG_FUNC0x0001) &&
     (en->env_value != NULL((void *)0)))
   return ((char * (*) (char *)) en->env_value)(name);
 else
   return en->env_value;
    }

  return NULL((void *)0);
204}

206/*
* Delete a variable from hash table. Return RESULT_TRUE if the deletion was
* successful, and RESULT_FALSE if the variable was not found.
*/
210int
211keynote_env_delete(char *name, struct environment **table,
                 unsigned int hashsize)
213{
  struct environment *en, *en2;
  unsigned int h;
  
  h = keynote_stringhash(name, hashsize);
  
  if (table[h] != NULL((void *)0))
  {
if (!strcmp(table[h]->env_name, name))
{
   en = table[h];
   table[h] = en->env_next;
   keynote_free_env(en);
   return RESULT_TRUE1;
}
else
 for (en = table[h]; 
      en->env_next != NULL((void *)0);
      en = en->env_next)
   if (!strcmp(en->env_next->env_name, name))
   {
en2 = en->env_next;
en->env_next = en2->env_next;
keynote_free_env(en2);
return RESULT_TRUE1;
   }
  }

 return RESULT_FALSE0;
242}

244/* 
* Add a new variable in hash table. Return RESULT_TRUE on success,
* ERROR_MEMORY on failure. If hashsize is 1, second argument is
* actually a pointer to a list. The arguments are duplicated.
*/
249int
250keynote_env_add(char *name, char *value, struct environment **table,
unsigned int hashsize, int flags)
252{
  struct environment *en;
  unsigned int h, i;
  
  en = calloc(1, sizeof(struct environment));
  if (en == NULL((void *)0)) {
14
←
Assuming 'en' is not equal to NULL→
15
←
Taking false branch→
keynote_errno = ERROR_MEMORY-1;
return -1;
  }

  en->env_name = strdup(name);
  if (en->env_name == NULL((void *)0)) {
16
←
Assuming field 'env_name' is not equal to NULL→
17
←
Taking false branch→
keynote_free_env(en);
keynote_errno = ERROR_MEMORY-1;
return -1;
  }

  if (flags & ENVIRONMENT_FLAG_REGEX0x0002) /* Regular expression for name */
18
←
Taking true branch→
  {
if ((i = regcomp(&(en->env_regex), name, REG_EXTENDED0001)) != 0)
19
←
Assuming the condition is false→
20
←
Taking false branch→
{
   keynote_free_env(en);
   if (i == REG_ESPACE12)
     keynote_errno = ERROR_MEMORY-1;
   else
     keynote_errno = ERROR_SYNTAX-2;
   return -1;
}
      en->env_flags |= ENVIRONMENT_FLAG_REGEX0x0002;
  }

  if (flags & ENVIRONMENT_FLAG_FUNC0x0001) /* Callback registration */
21
←
Assuming the condition is false→
22
←
Taking false branch→
  {
en->env_value = value;
en->env_flags |= ENVIRONMENT_FLAG_FUNC0x0001;
      ((char * (*) (char *))en->env_value)(KEYNOTE_CALLBACK_INITIALIZE"_KEYNOTE_CALLBACK_INITIALIZE");
if (keynote_errno != 0)
{
   keynote_free_env(en);
   return -1;
}
  }
  else
  {
en->env_value = strdup(value);
23
←
Value assigned to field 'env_value'→
if (en->env_value == NULL((void *)0)) {
24
←
Assuming field 'env_value' is equal to NULL→
25
←
Taking true branch→
   keynote_free_env(en);
26
←
Calling 'keynote_free_env'→
   keynote_errno = ERROR_MEMORY-1;
   return -1;
}
  }

  /* 
   * This means that new assignments of existing variable will override 
   * the old ones.
   */
  h = keynote_stringhash(name, hashsize);
  en->env_next = table[h];
  table[h] = en;
  return RESULT_TRUE1;
312}

314/*
* Cleanup an environment table.
*/
317void
318keynote_env_cleanup(struct environment **table, unsigned int hashsize)
319{
  struct environment *en2;

  if ((hashsize == 0) || (table == NULL((void *)0)))
    return;
  
  while (hashsize > 0)
  {
while (table[hashsize - 1] != NULL((void *)0)) {
   en2 = table[hashsize - 1]->env_next;
   keynote_free_env(table[hashsize - 1]);
   table[hashsize - 1] = en2;
}

hashsize--;
  }
335}

337/*
* Zero out the attribute structures, seed the RNG.
*/
340static int
341keynote_init_environment(void)
342{
  memset(keynote_current_session->ks_env_table, 0,
  HASHTABLESIZE37 * sizeof(struct environment *));
  memset(keynote_current_session->ks_assertion_table, 0,
  HASHTABLESIZE37 * sizeof(struct assertion *));
  keynote_current_session->ks_env_regex = NULL((void *)0);

  if (keynote_env_add("_ACTION_AUTHORIZERS",
	(char *) keynote_get_action_authorizers,
	keynote_current_session->ks_env_table, HASHTABLESIZE37,
	ENVIRONMENT_FLAG_FUNC0x0001) != RESULT_TRUE1)
    return -1;

  if (keynote_env_add("_VALUES", (char *) keynote_get_values,
	keynote_current_session->ks_env_table, HASHTABLESIZE37,
	ENVIRONMENT_FLAG_FUNC0x0001) != RESULT_TRUE1)
    return -1;

  return RESULT_TRUE1;
361}

363/*
* Return the index of argument in keynote_values[].
*/
366int
367keynote_retindex(char *s)
368{
  int i;
  
  for (i = 0; i < keynote_current_session->ks_values_num; i++)
    if (!strcmp(s, keynote_current_session->ks_values[i]))
return i;

  return -1;
376}

378/*
* Find a session by its id.
*/
381struct keynote_session *
382keynote_find_session(int sessid)
383{
  unsigned int h = sessid % SESSIONTABLESIZE37;
  struct keynote_session *ks;
  
  for (ks = keynote_sessions[h];
ks != NULL((void *)0);
ks = ks->ks_next)
    if (ks->ks_id == sessid)
return ks;

  return NULL((void *)0);
394}

396/*
* Add a session in the hash table.
*/
399static void
400keynote_add_session(struct keynote_session *ks)
401{
  unsigned int h = ks->ks_id % SESSIONTABLESIZE37;

  ks->ks_next = keynote_sessions[h];
  if (ks->ks_next != NULL((void *)0))
    ks->ks_next->ks_prev = ks;

  keynote_sessions[h] = ks;
409}

411/*
* Initialize a KeyNote session.
*/
414int
415kn_init(void)
416{
  keynote_errno = 0;
  keynote_current_session = calloc(1, sizeof(struct keynote_session));
  if (keynote_current_session == NULL((void *)0)) {
keynote_errno = ERROR_MEMORY-1;
return -1;
  }

  while (keynote_find_session(sessioncounter) != NULL((void *)0)) {
sessioncounter++;
if (sessioncounter < 0)
 sessioncounter = 0;
  }

  keynote_current_session->ks_id = sessioncounter++;
  keynote_init_environment();
  keynote_add_session(keynote_current_session);
  return keynote_current_session->ks_id;
434}

436/*
* Cleanup the action environment.
*/
439int
440kn_cleanup_action_environment(int sessid)
441{
  struct keynote_session *ks;

  keynote_errno = 0;
  if ((keynote_current_session == NULL((void *)0)) ||
(keynote_current_session->ks_id != sessid))
  {
keynote_current_session = keynote_find_session(sessid);
if (keynote_current_session == NULL((void *)0)) {
   keynote_errno = ERROR_NOTFOUND-3;
   return -1;
}
  }

  ks = keynote_current_session;

  /* Cleanup environment */
  keynote_env_cleanup(ks->ks_env_table, HASHTABLESIZE37);
  keynote_env_cleanup(&(ks->ks_env_regex), 1);

  return 0;
462}

464/*
* Close a session.
*/
467int
468kn_close(int sessid)
469{
  struct keynote_session *ks;
  struct assertion *as, *as2;
  int i;

  keynote_errno = 0;
  if ((keynote_current_session == NULL((void *)0)) ||
(keynote_current_session->ks_id != sessid))
  {
keynote_current_session = keynote_find_session(sessid);
if (keynote_current_session == NULL((void *)0)) {
   keynote_errno = ERROR_NOTFOUND-3;
   return -1;
}
  }

  ks = keynote_current_session;

  /* Cleanup environment -- no point using kn_cleanup_action_environment() */
  keynote_env_cleanup(ks->ks_env_table, HASHTABLESIZE37);
  keynote_env_cleanup(&(ks->ks_env_regex), 1);

  /* Cleanup assertions */
  for (i = 0; i < HASHTABLESIZE37; i++)
    for (as = ks->ks_assertion_table[i];
  as != NULL((void *)0);
  as = as2)
    {
 as2 = as->as_next;
 keynote_free_assertion(as);
    }

  /* Cleanup action authorizers */
  keynote_keylist_free(ks->ks_action_authorizers);

  /* Unlink from chain */
  if (ks->ks_prev == NULL((void *)0)) {
keynote_sessions[ks->ks_id % SESSIONTABLESIZE37] = ks->ks_next;
if (ks->ks_next != NULL((void *)0))
 ks->ks_next->ks_prev = NULL((void *)0);

  }
  else
  {
ks->ks_prev->ks_next = ks->ks_next;
if (ks->ks_next != NULL((void *)0))
 ks->ks_next->ks_prev = ks->ks_prev;
  }
  
  free(ks);
  keynote_current_session = NULL((void *)0);
  return 0;
521}

523/*
* Add an action attribute.
*/
526int
527kn_add_action(int sessid, char *name, char *value, int flags)
528{
  int i;

  keynote_errno = 0;
  if (name == NULL((void *)0) || value == NULL((void *)0) || name[0] == '_') {
6
←
Assuming 'name' is not equal to NULL→
7
←
Assuming 'value' is not equal to NULL→
8
←
Assuming the condition is false→
9
←
Taking false branch→
keynote_errno = ERROR_SYNTAX-2;
return -1;
  }

  if (keynote_current_session9.1
'keynote_current_session' is not equal to NULL
 == NULL((void *)0) ||
10
←
Taking false branch→
keynote_current_session->ks_id != sessid9.2
'sessid' is equal to field 'ks_id'
)
  {
keynote_current_session = keynote_find_session(sessid);
if (keynote_current_session == NULL((void *)0)) {
   keynote_errno = ERROR_NOTFOUND-3;
   return -1;
}
  }

  if (flags & ENVIRONMENT_FLAG_REGEX0x0002)
11
←
Assuming the condition is true→
12
←
Taking true branch→
    i = keynote_env_add(name, value, 
13
←
Calling 'keynote_env_add'→
	  &(keynote_current_session->ks_env_regex), 1, flags);
  else
    i = keynote_env_add(name, value, keynote_current_session->ks_env_table,
	  HASHTABLESIZE37, flags);

  if (i == RESULT_TRUE1)
    return 0;
  else
    return -1;
558}

560/*
* Remove an action attribute.
*/
563int
564kn_remove_action(int sessid, char *name)
565{
  int i;

  keynote_errno = 0;
  if (name == NULL((void *)0) || name[0] == '_') {
keynote_errno = ERROR_SYNTAX-2;
return -1;
  }

  if (keynote_current_session == NULL((void *)0) ||
keynote_current_session->ks_id != sessid)
  {
keynote_current_session = keynote_find_session(sessid);
if (keynote_current_session == NULL((void *)0)) {
   keynote_errno = ERROR_NOTFOUND-3;
   return -1;
}
  }

  i = keynote_env_delete(name, keynote_current_session->ks_env_table,
	   HASHTABLESIZE37);
  if (i == RESULT_TRUE1)
    return 0;

  i = keynote_env_delete(name, &(keynote_current_session->ks_env_regex),
	   HASHTABLESIZE37);
  if (i == RESULT_TRUE1)
    return 0;

  keynote_errno = ERROR_NOTFOUND-3;
  return -1;
596}

598/*
* Execute a query.
*/
601int
602kn_do_query(int sessid, char **returnvalues, int numvalues)
603{
  struct assertion *as;
  int i;

  keynote_errno = 0;
  if (keynote_current_session == NULL((void *)0) ||
keynote_current_session->ks_id != sessid)
  {
keynote_current_session = keynote_find_session(sessid);
if (keynote_current_session == NULL((void *)0)) {
   keynote_errno = ERROR_NOTFOUND-3;
   return -1;
}
  }

  /* Check that we have at least one action authorizer */
  if (keynote_current_session->ks_action_authorizers == NULL((void *)0)) {
keynote_errno = ERROR_NOTFOUND-3;
return -1;
  }

  /* 
   * We may use already set returnvalues, or use new ones,
   * but we must have some before we can evaluate.
   */
  if (returnvalues == NULL((void *)0) &&
keynote_current_session->ks_values == NULL((void *)0))
  {
keynote_errno = ERROR_SYNTAX-2;
return -1;
  }

  /* Replace any existing returnvalues */
  if (returnvalues != NULL((void *)0)) {
keynote_current_session->ks_values = returnvalues;
keynote_current_session->ks_values_num = numvalues;
  }

  /* Reset assertion state from any previous queries */
  for (i = 0; i < HASHTABLESIZE37; i++)
    for (as = keynote_current_session->ks_assertion_table[i];
  as != NULL((void *)0);
  as = as->as_next)
    {
 as->as_kresult = KRESULT_UNTOUCHED0;
 as->as_result = 0;
 as->as_internalflags &= ~ASSERT_IFLAG_PROCESSED0x0010;
 as->as_error = 0;
 if (as->as_internalflags & ASSERT_IFLAG_WEIRDSIG0x0004)
   as->as_sigresult = SIGRESULT_UNTOUCHED0;
    }

  return keynote_evaluate_query();
656}

658/*
* Return assertions that failed, by error type.
*/
661int
662kn_get_failed(int sessid, int type, int num)
663{
  struct assertion *as;
  int i;

  keynote_errno = 0;
  if (keynote_current_session == NULL((void *)0) ||
keynote_current_session->ks_id != sessid)
  {
keynote_current_session = keynote_find_session(sessid);
if (keynote_current_session == NULL((void *)0)) {
   keynote_errno = ERROR_NOTFOUND-3;
   return -1;
}
  }

  for (i = 0; i < HASHTABLESIZE37; i++)
    for (as = keynote_current_session->ks_assertion_table[i];
  as != NULL((void *)0);
  as = as->as_next)
switch (type)
{
   case KEYNOTE_ERROR_ANY0:
if ((as->as_error != 0) ||
    ((as->as_sigresult != SIGRESULT_TRUE2) &&
     !(as->as_sigresult == SIGRESULT_UNTOUCHED0) &&
     !(as->as_flags & ASSERT_FLAG_LOCAL0x0001)))
  if (num-- == 0)  /* Return it if it's the num-th found */
    return as->as_id;
break;

   case KEYNOTE_ERROR_MEMORY2:
if (as->as_error == ERROR_MEMORY-1)
  if (num-- == 0)
    return as->as_id;
break;

   case KEYNOTE_ERROR_SYNTAX1:
if (as->as_error == ERROR_SYNTAX-2)
  if (num-- == 0)
    return as->as_id;
break;

   case KEYNOTE_ERROR_SIGNATURE3:
if ((as->as_sigresult != SIGRESULT_TRUE2) &&
    !(as->as_sigresult == SIGRESULT_UNTOUCHED0) &&
    !(as->as_flags & ASSERT_FLAG_LOCAL0x0001))
  if (num-- == 0)
    return as->as_id;
break;
}

  keynote_errno = ERROR_NOTFOUND-3;
  return -1;
716}

718/*
* Simple API for doing a single KeyNote query.
*/
721int
722kn_query(struct environment *env, char **retvalues, int numval,
char **trusted, int *trustedlen, int numtrusted,
char **untrusted, int *untrustedlen, int numuntrusted,
char **authorizers, int numauthorizers)
726{
  struct environment *en;
  int sessid, i, serrno;

  keynote_errno = 0;
  if ((sessid = kn_init()) == -1)
1
Assuming the condition is false→
2
←
Taking false branch→
    return -1;

  /* Action set */
  for (en = env; en != NULL((void *)0); en = en->env_next)
3
←
Assuming 'en' is not equal to NULL→
4
←
Loop condition is true.  Entering loop body→
    if (kn_add_action(sessid, en->env_name, en->env_value,
5
←
Calling 'kn_add_action'→
        en->env_flags) == -1)
    {
 serrno = keynote_errno;
 kn_close(sessid);
 keynote_errno = serrno;
 return -1;
    }

  /* Locally trusted assertions */
  for (i = 0; i < numtrusted; i++)
    if ((kn_add_assertion(sessid, trusted[i], trustedlen[i],
 ASSERT_FLAG_LOCAL0x0001) == -1) && (keynote_errno == ERROR_MEMORY-1))
    {
 serrno = keynote_errno;
 kn_close(sessid);
 keynote_errno = serrno;
 return -1;
    }

  /* Untrusted assertions */
  for (i = 0; i < numuntrusted; i++)
    if ((kn_add_assertion(sessid, untrusted[i], untrustedlen[i], 0) == -1)
 && (keynote_errno == ERROR_MEMORY-1))
    {
 serrno = keynote_errno;
 kn_close(sessid);
 keynote_errno = serrno;
 return -1;
    }

  /* Authorizers */
  for (i = 0; i < numauthorizers; i++)
    if (kn_add_authorizer(sessid, authorizers[i]) == -1)
    {
 serrno = keynote_errno;
 kn_close(sessid);
 keynote_errno = serrno;
 return -1;
    }

  i = kn_do_query(sessid, retvalues, numval);
  serrno = keynote_errno;
  kn_close(sessid);

  if (serrno)
    keynote_errno = serrno;

  return i;
785}

787/*
* Read a buffer, break it up in assertions.
*/
790char **
791kn_read_asserts(char *buffer, int bufferlen, int *numassertions)
792{
  int bufsize = 32, i, flag, valid;
  char **buf, **tempbuf, *ptr;

  keynote_errno = 0;
  if (buffer == NULL((void *)0)) {
keynote_errno = ERROR_SYNTAX-2;
return NULL((void *)0);
  }

  if ((buf = calloc(bufsize, sizeof(char *))) == NULL((void *)0)) {
keynote_errno = ERROR_MEMORY-1;
return NULL((void *)0);
  }

  /*
   * We'll go through the whole buffer looking for consecutive newlines,
   * which imply newline separation. We use the valid flag to keep
   * track of whether there may be an assertion after the last pair of
   * newlines, or whether there may be an assertion in the buffer to
   * begin with, if there are no consecutive newlines.
   */
  for (i = 0, flag = 0, valid = 0, *numassertions = 0, ptr = buffer;
i < bufferlen;
i++)
  {
if (buffer[i] == '\n')
{
   if (flag)  /* Two newlines in a row, copy if there's anything */
   {
if (valid)  /* Something there */
{
    /* Allocate enough memory */
    buf[*numassertions] = calloc((buffer + i) - ptr
					  + 1, sizeof(char));
    if (buf[*numassertions] == NULL((void *)0)) {
	/* Free any already-allocated strings */
	for (flag = 0; flag < *numassertions; flag++)
	  free(buf[flag]);
	free(buf);
	keynote_errno = ERROR_MEMORY-1;
	return NULL((void *)0);
    }

    /* Copy string */
    memcpy(buf[*numassertions], ptr, (buffer + i) - ptr);
    (*numassertions)++;
}

valid = 0; /* Reset */
flag = 0;
ptr = buffer + i + 1; /* Point right after this newline */

/* See if we need to resize the buffer */
if (*numassertions > bufsize - 4)
{
    /* Allocate twice the space */
    tempbuf = reallocarray(buf, bufsize, 2 * sizeof(char *));
    if (tempbuf == NULL((void *)0)) {
	for (flag = 0; flag < *numassertions; flag++)
	  free(buf[flag]);
	free(buf);
	keynote_errno = ERROR_MEMORY-1;
	return NULL((void *)0);
    }

    buf = tempbuf;
    bufsize *= 2;
}
   }
   else
     flag = 1;  /* One newline so far */

   continue;
}
else
 flag = 0;

if (!isspace((unsigned char)buffer[i]))
 valid = 1;
  }

  /*
   * There may be a valid assertion after the last pair of newlines.
   * Notice that because of the resizing check above, there will be
   * a valid memory location to store this last string.
   */
  if (valid)
  {
/* This one's easy, we can just use strdup() */
if ((buf[*numassertions] = strdup(ptr)) == NULL((void *)0)) {
   for (flag = 0; flag < *numassertions; flag++)
     free(buf[flag]);
   free(buf);
   keynote_errno = ERROR_MEMORY-1;
   return NULL((void *)0);
}
(*numassertions)++;
  }

  return buf;
893}

895/*
* Return the authorizer key for a given assertion.
*/
898void *
899kn_get_authorizer(int sessid, int assertid, int *algorithm)
900{
  struct assertion *as;
  int i;

  keynote_errno = *algorithm = 0;
  if (keynote_current_session == NULL((void *)0) ||
keynote_current_session->ks_id != sessid)
  {
keynote_current_session = keynote_find_session(sessid);
if (keynote_current_session == NULL((void *)0)) {
   keynote_errno = ERROR_NOTFOUND-3;
   return NULL((void *)0);
}
  }

  /* Traverse the hash table looking for assertid */
  for (i = 0; i < HASHTABLESIZE37; i++)
    for (as = keynote_current_session->ks_assertion_table[i];
  as != NULL((void *)0);
  as = as->as_next)
if (as->as_id == assertid)
 goto out;

out:
  if (as == NULL((void *)0)) {
keynote_errno = ERROR_NOTFOUND-3;
return NULL((void *)0);
  }

  if (as->as_authorizer == NULL((void *)0))
    if (keynote_evaluate_authorizer(as, 1) != RESULT_TRUE1)
return NULL((void *)0);

  *algorithm = as->as_signeralgorithm;
  return as->as_authorizer;
935}

937/*
* Return the licensees for a given assertion.
*/
940struct keynote_keylist *
941kn_get_licensees(int sessid, int assertid)
942{
  struct assertion *as;
  int i;

  keynote_errno = 0;
  if (keynote_current_session == NULL((void *)0) ||
keynote_current_session->ks_id != sessid)
  {
keynote_current_session = keynote_find_session(sessid);
if (keynote_current_session == NULL((void *)0)) {
   keynote_errno = ERROR_NOTFOUND-3;
   return NULL((void *)0);
}
  }

  /* Traverse the hash table looking for assertid */
  for (i = 0; i < HASHTABLESIZE37; i++)
    for (as = keynote_current_session->ks_assertion_table[i];
  as != NULL((void *)0);
  as = as->as_next)
if (as->as_id == assertid)
 goto out;

out:
  if (as == NULL((void *)0)) {
keynote_errno = ERROR_NOTFOUND-3;
return NULL((void *)0);
  }

  if (as->as_keylist == NULL((void *)0))
    if (keynote_parse_keypred(as, 1) != RESULT_TRUE1)
return NULL((void *)0);

  return (struct keynote_keylist *) as->as_keylist;
976}