DataMuseum.dk

Presents historical artifacts from the history of:

DKUUG/EUUG Conference tapes

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about DKUUG/EUUG Conference tapes

Excavated with: AutoArchaeologist - Free & Open Source Software. 

top - metrics - download
Index: T r

⟦2ed16f60e⟧ TextFile

    Length: 7006 (0x1b5e)
    Types: TextFile
    Names: »rdbmd.c«

Derivation

└─⟦3d0c2be1b⟧ Bits:30001254 ISODE-5.0 Tape
    └─⟦eba4602b1⟧ »./isode-5.0.tar.Z« 
        └─⟦d3ac74d73⟧ 
            └─⟦this⟧ »isode-5.0/others/rdbm/rdbmd.c«

TextFile

/* rdbmd.c - remote operations dbm -- responder */

#ifndef	lint
static char *rcsid = "$Header: /f/osi/others/rdbm/RCS/rdbmd.c,v 6.0 89/03/18 23:36:22 mrose Rel $";
#endif	lint

#include <dbm.h>
#undef	NULL
#include <stdio.h>
#include "../lookup/ryresponder.h"
#include "RDBM-ops.h"
#include "RDBM-types.h"

/* \f

   DATA */

static char *myservice = "dbmstore";

static int   execuid = 1;
static int   execgid = 1;


					/* OPERATIONS */
int	op_dbminit (), op_fetch (), op_store (), op_delete (), op_firstkey (),
	op_nextkey (); 

static struct dispatch dispatches[] = {
  "dbminit", operation_RDBM_dbminit, op_dbminit,
  "fetch", operation_RDBM_fetch, op_fetch,
  "store", operation_RDBM_store, op_store,
  "delete", operation_RDBM_delete, op_delete,
  "firstkey", operation_RDBM_firstkey, op_firstkey,
  "nextkey", operation_RDBM_nextkey, op_nextkey,

  NULL
};

/* \f

   MAIN */

/* ARGSUSED */

main(argc,argv,envp)
int argc;
char **argv,
     **envp;
{
    (void) setgid (execgid);
    (void) setuid (execuid);

    (void) ryresponder(argc, argv, PLocalHostName (), myservice, dispatches,
		       table_RDBM_Operations, NULLIFP, NULLIFP);

    exit(0);		/* NOTREACHED */
}

/* \f

   OPERATIONS */

static int op_dbminit(sd, ryo, rox, in, roi)
int sd;
struct RyOperation *ryo;
struct RoSAPinvoke *rox;
caddr_t in;
struct RoSAPindication *roi;
{
  char     *cp;
  register struct type_UNIV_PrintableString *arg =
				    (struct type_UNIV_PrintableString *) in;
  struct type_RDBM_Status ress;
  register struct type_RDBM_Status *res = &ress;

  if (rox->rox_nolinked == 0) {
    advise(NULLCP,LOG_INFO,
	   "RO-INVOKE.INDICATION/%d:  %s, unknown linkage %d",
	   sd, ryo->ryo_name, rox->rox_linkid);
    return ureject(sd, ROS_IP_LINKED, rox, roi);
  }
  if (debug)
      advise(NULLCP, LOG_DEBUG, "RO-INVOKE.INDICATION/%d:  %s",
	     sd, ryo->ryo_name);

  cp = qb2str (arg);
  res -> parm = dbminit(cp);
  free (cp);
  
  if (RyDsResult(sd, rox->rox_id, (caddr_t) res, ROS_NOPRIO, roi) == NOTOK)
      ros_adios(&roi->roi_preject,"RESULT");
  
  return OK;
}

/* \f

 */
	 
static int op_fetch(sd, ryo, rox, in, roi)
int sd;
struct RyOperation *ryo;
struct RoSAPinvoke *rox;
caddr_t in;
struct RoSAPindication *roi;
{
  register struct type_RDBM_Datum *arg = (struct type_RDBM_Datum *) in;
  register struct type_RDBM_Datum *res;
  datum arg_datum;
  datum res_datum;

  if (rox->rox_nolinked == 0) {
    advise(NULLCP,LOG_INFO,
	 "RO-INVOKE.INDICATION/%d:  %s, unknown linkage %d",
	   sd, ryo->ryo_name, rox->rox_linkid);
    return ureject(sd, ROS_IP_LINKED, rox, roi);
  }
  if (debug)
      advise(NULLCP,LOG_DEBUG,"RO-INVOKE.INDICATION/%d:  %s",
	     sd, ryo->ryo_name);
  
  arg_datum.dptr = qb2str (arg), arg_datum.dsize = arg->qb_len;

  res_datum = fetch(arg_datum);
  free (arg_datum.dptr);
  
  res = str2qb(res_datum.dptr, res_datum.dsize, 1);
  
  if (RyDsResult(sd, rox->rox_id, (caddr_t) res, ROS_NOPRIO, roi) == NOTOK)
    ros_adios(&roi->roi_preject,"RESULT");
  
  free_RDBM_Datum (res);

  return OK;
}

/* \f

 */
	 
static int op_store(sd, ryo, rox, in, roi)
int sd;
struct RyOperation *ryo;
struct RoSAPinvoke *rox;
caddr_t in;
struct RoSAPindication *roi;
{
  register struct type_RDBM_Pair *arg = (struct type_RDBM_Pair *) in;
  struct type_RDBM_Status ress;
  register struct type_RDBM_Status *res = &ress;
  datum key_datum;
  datum dat_datum;

  if (rox->rox_nolinked == 0) {
    advise(NULLCP,LOG_INFO,
	   "RO-INVOKE.INDICATION/%d:  %s, unknown linkage %d",
	   sd, ryo->ryo_name, rox->rox_linkid);
    return ureject(sd, ROS_IP_LINKED, rox, roi);
  }
  if (debug)
      advise(NULLCP, LOG_DEBUG, "RO-INVOKE.INDICATION/%d:  %s",
	     sd, ryo->ryo_name);

  key_datum.dptr = qb2str (arg->key), key_datum.dsize = arg->key->qb_len;
  dat_datum.dptr = qb2str (arg->content), dat_datum.dsize = arg->content->qb_len;

  res->parm = store(key_datum, dat_datum);
  free (key_datum.dptr);
  free (dat_datum.dptr);
  
  if (RyDsResult(sd, rox->rox_id, (caddr_t) res, ROS_NOPRIO, roi) == NOTOK)
    ros_adios(&roi->roi_preject,"RESULT");
  
  return OK;
}
	 
/* \f

 */

static int op_delete(sd, ryo, rox, in, roi)
int sd;
struct RyOperation *ryo;
struct RoSAPinvoke *rox;
caddr_t in;
struct RoSAPindication *roi;
{
  register struct type_RDBM_Datum *arg = (struct type_RDBM_Datum *) in;
  struct type_RDBM_Status ress;
  register struct type_RDBM_Status *res = &ress;
  datum key_datum;

  if (rox->rox_nolinked == 0) {
    advise(NULLCP,LOG_INFO,
	   "RO-INVOKE.INDICATION/%d:  %s, unknown linkage %d",
	   sd, ryo->ryo_name, rox->rox_linkid);
    return ureject(sd, ROS_IP_LINKED, rox, roi);
  }
  if (debug)
      advise(NULLCP, LOG_DEBUG, "RO-INVOKE.INDICATION/%d:  %s",
	     sd, ryo->ryo_name);

  key_datum.dptr = qb2str (arg), key_datum.dsize = arg->qb_len;

  res->parm = delete(key_datum);
  free (key_datum.dptr);

  if (RyDsResult(sd, rox->rox_id, (caddr_t) res, ROS_NOPRIO, roi) == NOTOK)
    ros_adios(&roi->roi_preject,"RESULT");

  return OK;
}
	 
/* \f

 */

/* ARGSUSED */

static int op_firstkey(sd, ryo, rox, in, roi)
int sd;
struct RyOperation *ryo;
struct RoSAPinvoke *rox;
caddr_t in;
struct RoSAPindication *roi;
{
  register struct type_RDBM_Datum *res;
  datum key_datum;

  if (rox->rox_nolinked == 0) {
    advise(NULLCP,LOG_INFO,
	   "RO-INVOKE.INDICATION/%d:  %s, unknown linkage %d",
	   sd, ryo->ryo_name, rox->rox_linkid);
    return ureject(sd, ROS_IP_LINKED, rox, roi);
  }
  if (debug)
      advise(NULLCP, LOG_DEBUG, "RO-INVOKE.INDICATION/%d:  %s",
	     sd, ryo->ryo_name);

  key_datum = firstkey();

  res = str2qb(key_datum.dptr, key_datum.dsize, 1);

  if (RyDsResult(sd, rox->rox_id, (caddr_t) res, ROS_NOPRIO, roi) == NOTOK)
    ros_adios(&roi->roi_preject,"RESULT");
  
  free_RDBM_Datum (res);

  return OK;
}
	 
/* \f

 */

static int op_nextkey(sd, ryo, rox, in, roi)
int sd;
struct RyOperation *ryo;
struct RoSAPinvoke *rox;
caddr_t in;
struct RoSAPindication *roi;
{
  register struct type_RDBM_Datum *arg = (struct type_RDBM_Datum *) in;
  register struct type_RDBM_Datum *res;
  datum key_datum;
  datum nkey_datum;

  if (rox->rox_nolinked == 0) {
    advise(NULLCP,LOG_INFO,
	   "RO-INVOKE.INDICATION/%d:  %s, unknown linkage %d",
	   sd, ryo->ryo_name, rox->rox_linkid);
    return ureject(sd, ROS_IP_LINKED, rox, roi);
  }
  if (debug)
      advise(NULLCP, LOG_DEBUG, "RO-INVOKE.INDICATION/%d:  %s",
	     sd, ryo->ryo_name);

  key_datum.dptr = qb2str (arg), key_datum.dsize = arg->qb_len;
  
  nkey_datum = nextkey(key_datum);
  free (key_datum.dptr);

  res = str2qb(nkey_datum.dptr, nkey_datum.dsize, 1);
  
  if (RyDsResult(sd, rox->rox_id, (caddr_t) res, ROS_NOPRIO, roi) == NOTOK)
    ros_adios(&roi->roi_preject,"RESULT");
  
  free_RDBM_Datum (res);

  return OK;
}

/* \f

   U-REJECT */

static int ureject(sd, reason, rox, roi)
int sd,
  reason;
struct RoSAPinvoke *rox;
struct RoSAPindication *roi;
{
  if (RyDsUReject(sd, rox->rox_id,reason,ROS_NOPRIO,roi) == NOTOK)
    ros_adios(&roi->roi_preject,"U-REJECT");
  return(OK);
}