source: trunk/minix/servers/ds/store.c@ 10

/* Implementation of the Data Store. */

#include "inc.h"

/* Allocate space for the data store. */
PRIVATE struct data_store ds_store[NR_DS_KEYS];
PRIVATE int nr_in_use;

PRIVATE _PROTOTYPE(int find_key, (int key, struct data_store **dsp));
PRIVATE _PROTOTYPE(int set_owner, (struct data_store *dsp, void *auth_ptr));
PRIVATE _PROTOTYPE(int is_authorized, (struct data_store *dsp, void *auth_ptr));


PRIVATE int set_owner(dsp, ap)
struct data_store *dsp;                         /* data store structure */
void *ap;                                       /* authorization pointer */
{
  /* Authorize the caller. */
  return(TRUE);
}


PRIVATE int is_authorized(dsp, ap)
struct data_store *dsp;                         /* data store structure */
void *ap;                                       /* authorization pointer */
{
  /* Authorize the caller. */
  return(TRUE);
}


PRIVATE int find_key(key, dsp)
int key;                                        /* key to look up */
struct data_store **dsp;                        /* store pointer here */
{
  register int i;

  *dsp = NULL;
  for (i=0; i<NR_DS_KEYS; i++) {
      if ((ds_store[i].ds_flags & DS_IN_USE) && ds_store[i].ds_key == key) {
          *dsp = &ds_store[i];
          return(TRUE);                         /* report success */
      }
  }
  return(FALSE);                                /* report not found */
}


PUBLIC int do_publish(m_ptr)
message *m_ptr;                                 /* request message */
{
  struct data_store *dsp;

  /* Store (key,value)-pair. First see if key already exists. If so, 
   * check if the caller is allowed to overwrite the value. Otherwise
   * find a new slot and store the new value. 
   */
  if (find_key(m_ptr->DS_KEY, &dsp)) {                  /* look up key */
      if (! is_authorized(dsp,m_ptr->DS_AUTH)) {        /* check if owner */
          return(EPERM);
      }
  } 
  else {                                                /* find a new slot */
      if (nr_in_use >= NR_DS_KEYS) {
          return(EAGAIN);                               /* store is full */
      } else {
          dsp = &ds_store[nr_in_use];                   /* new slot found */
          dsp->ds_key = m_ptr->DS_KEY;
          if (! set_owner(dsp,m_ptr->DS_AUTH)) {        /* associate owner */
              return(EINVAL);
          }
          dsp->ds_nr_subs = 0;                          /* nr of subscribers */
          dsp->ds_flags = DS_IN_USE;                    /* initialize slot */
          nr_in_use ++;
      }
  }

  /* At this point we have a data store pointer and know the caller is 
   * authorize to write to it. Set all fields as requested.
   */
  dsp->ds_val_l1 = m_ptr->DS_VAL_L1;            /* store all data */
  dsp->ds_val_l2 = m_ptr->DS_VAL_L2;    

  /* If the data is public. Check if there are any subscribers to this key. 
   * If so, notify all subscribers so that they can retrieve the data, if 
   * they're still interested.
   */
  if ((dsp->ds_flags & DS_PUBLIC) && dsp->ds_nr_subs > 0) {

      /* Subscriptions are not yet implemented. */
  }

  return(OK);
}


PUBLIC int do_retrieve(m_ptr)
message *m_ptr;                                 /* request message */
{
  struct data_store *dsp;

  /* Retrieve data. Look up the key in the data store. Return an error if it
   * is not found. If this data is private, only the owner may retrieve it.
   */ 
  if (find_key(m_ptr->DS_KEY, &dsp)) {                  /* look up key */

      /* If the data is not public, the caller must be authorized. */
      if (! dsp->ds_flags & DS_PUBLIC) {                /* check if private */
          if (! is_authorized(dsp,m_ptr->DS_AUTH)) {    /* authorize call */
              return(EPERM);                            /* not allowed */
          }
      }

      /* Data is public or the caller is authorized to retrieve it. */
      printf("DS retrieves data: key %d (found %d), l1 %u, l2 %u\n",
                m_ptr->DS_KEY, dsp->ds_key, dsp->ds_val_l1, dsp->ds_val_l2);
      m_ptr->DS_VAL_L1 = dsp->ds_val_l1;                /* return value */
      m_ptr->DS_VAL_L2 = dsp->ds_val_l2;                /* return value */
      return(OK);                                       /* report success */
  }
  return(ESRCH);                                        /* key not found */
}


PUBLIC int do_subscribe(m_ptr)
message *m_ptr;                                 /* request message */
{
  /* Subscribe to a key of interest. Only existing and public keys can be
   * subscribed to. All updates to the key will cause a notification message
   * to be sent to the subscribed. On success, directly return a copy of the
   * data for the given key. 
   */
  return(ENOSYS);
}


/*===========================================================================*
 *                              do_getsysinfo                                *
 *===========================================================================*/
PUBLIC int do_getsysinfo(m_ptr)
message *m_ptr;
{
  vir_bytes src_addr, dst_addr;
  int dst_proc;
  size_t len;
  int s;

  switch(m_ptr->m1_i1) {
  case SI_DATA_STORE:
        src_addr = (vir_bytes) ds_store;
        len = sizeof(struct data_store) * NR_DS_KEYS;
        break; 
  default:
        return(EINVAL);
  }

  dst_proc = m_ptr->m_source;
  dst_addr = (vir_bytes) m_ptr->m1_p1;
  if (OK != (s=sys_datacopy(SELF, src_addr, dst_proc, dst_addr, len)))
        return(s);
  return(OK);
}