vxi11 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ac7a2f3a2b92e437762c4a4b3f5dcc678737d382
-  data.tar.gz: 72692c13bde2d578a265cd9e1438ea5786af33f7
+  metadata.gz: f82aade66c461ffe8bf7edebfac762b8f390cadd
+  data.tar.gz: 860027ea5f1bb45fa383563e087b821a87d587ec
 SHA512:
-  metadata.gz: bad0d97c33b361ead33b59169bb056229d78f5ff6cfe0360b1b5df1354462fddf26a061f8661e03f2e30d66bac58b95634e2e5b2edd764801e9224ff081ecaa4
-  data.tar.gz: 9441982387d9d4f83efa8744f4c50374013b1da11d3fe2c25c8c151f1f5bf5e56049e592b79aeb8c9164c1ce544c24126dad55af735b3af5e49f56b215debf82
+  metadata.gz: 00549ea8904e2ec2a8bc49fafbdc527b3d82bdfccf0901cd56e13d921039c11f7d6c196e74001a12ef0ae1853732532f86435ceb0cd47b34168d36c3cee4f35e
+  data.tar.gz: ad0efb6ae1b20aa7c41b33d9a4dcd79928b983c891ebe512ca8616a3091dc99a36f6243b9877fe34ad70a757b3ab224ed36bff1b5742f799c97afcaf91014520

data/ext/vxi11/clnt_find_services.h

@@ -0,0 +1,97 @@
+/*
+ * This code contains modifications to clnt_broadcast available in the
+ * rpc.subproj/pmap_rmt.c.  A summary of modifications:
+ *
+ *  1.  Allow blocking time to be set by the user, the previous hard-coded
+ *  times were not general enough. 
+ *  2.  Calls PORTMAP_GETPORT to determine if there's a service that satisfies
+ *  the input specifications 
+ *  3.  The clnt_broadcast has been renamed to clnt_find_services.
+ *
+ *  M. Marino November 2011
+ *
+ */
+/*
+ * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ * 
+ * Portions Copyright (c) 1999 Apple Computer, Inc.  All Rights
+ * Reserved.  This file contains Original Code and/or Modifications of
+ * Original Code as defined in and that are subject to the Apple Public
+ * Source License Version 1.1 (the "License").  You may not use this file
+ * except in compliance with the License.  Please obtain a copy of the
+ * License at http://www.apple.com/publicsource and read it before using
+ * this file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT.  Please see the
+ * License for the specific language governing rights and limitations
+ * under the License.
+ * 
+ * @APPLE_LICENSE_HEADER_END@
+ */
+/*
+ * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
+ * unrestricted use provided that this legend is included on all tape
+ * media and as a part of the software program in whole or part.  Users
+ * may copy or modify Sun RPC without charge, but are not authorized
+ * to license or distribute it to anyone else except as part of a product or
+ * program developed by the user.
+ * 
+ * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
+ * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
+ * 
+ * Sun RPC is provided with no support and without any obligation on the
+ * part of Sun Microsystems, Inc. to assist in its use, correction,
+ * modification or enhancement.
+ * 
+ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
+ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
+ * OR ANY PART THEREOF.
+ * 
+ * In no event will Sun Microsystems, Inc. be liable for any lost revenue
+ * or profits or other special, indirect and consequential damages, even if
+ * Sun has been advised of the possibility of such damages.
+ * 
+ * Sun Microsystems, Inc.
+ * 2550 Garcia Avenue
+ * Mountain View, California  94043
+ */
+
+
+#ifndef _RPC_CLNT_FIND_SERVICES_H
+#define _RPC_CLNT_FIND_SERVICES_H
+#include <rpc/rpc.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct sockaddr_in;
+typedef bool_t (*resultfoundproc_t)(struct sockaddr_in *);
+
+/*
+ * The following is based on clnt_broadcast, with important differences that it
+ * is only searching for devices which have the requested services.  There is
+ * also a timeout variable which doesn't normally exist in clnt_broadcast.  If
+ * found_callback is non NULL, this function is called when a device is found
+ * with the requested service.
+ */
+enum clnt_stat 
+#if (defined __LP64__) && (defined __APPLE__)
+clnt_find_services(uint32_t prog, uint32_t vers, uint32_t proc, 
+#else
+clnt_find_services(u_long prog, u_long vers, u_long proc, 
+#endif
+                   struct timeval *t, resultfoundproc_t found_callback);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !_RPC_CLNT_FIND_SERVICES_H */

data/ext/vxi11/vxi11.h

@@ -0,0 +1,5 @@
+#ifdef __APPLE__
+#include "vxi11_darwin.inc"
+#else
+#include "vxi11_linux.inc"
+#endif

data/ext/vxi11/vxi11_clnt_darwin.inc

@@ -0,0 +1,234 @@
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include "vxi11.h"                                       
+#include <string.h>                                                       
+#undef clnt_call                                                          
+#define clnt_call(rh, proc, xargs, argsp, xres, resp, secs)              \
+     ((*(rh)->cl_ops->cl_call)(rh, proc, (xdrproc_t)xargs, argsp, (xdrproc_t)xres, resp, secs)) 
+
+/* Default timeout can be changed using clnt_control() */
+static struct timeval TIMEOUT = { 25, 0 };
+
+Device_Error *
+device_abort_1(argp, clnt)
+	Device_Link *argp;
+	CLIENT *clnt;
+{
+	static Device_Error clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call(clnt, device_abort, xdr_Device_Link, argp, xdr_Device_Error, &clnt_res, TIMEOUT) != RPC_SUCCESS)
+		return (NULL);
+	return (&clnt_res);
+}
+
+Create_LinkResp *
+create_link_1(argp, clnt)
+	Create_LinkParms *argp;
+	CLIENT *clnt;
+{
+	static Create_LinkResp clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call(clnt, create_link, xdr_Create_LinkParms, argp, xdr_Create_LinkResp, &clnt_res, TIMEOUT) != RPC_SUCCESS)
+		return (NULL);
+	return (&clnt_res);
+}
+
+Device_WriteResp *
+device_write_1(argp, clnt)
+	Device_WriteParms *argp;
+	CLIENT *clnt;
+{
+	static Device_WriteResp clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call(clnt, device_write, xdr_Device_WriteParms, argp, xdr_Device_WriteResp, &clnt_res, TIMEOUT) != RPC_SUCCESS)
+		return (NULL);
+	return (&clnt_res);
+}
+
+Device_ReadResp *
+device_read_1(argp, clnt)
+	Device_ReadParms *argp;
+	CLIENT *clnt;
+{
+	static Device_ReadResp clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call(clnt, device_read, xdr_Device_ReadParms, argp, xdr_Device_ReadResp, &clnt_res, TIMEOUT) != RPC_SUCCESS)
+		return (NULL);
+	return (&clnt_res);
+}
+
+Device_ReadStbResp *
+device_readstb_1(argp, clnt)
+	Device_GenericParms *argp;
+	CLIENT *clnt;
+{
+	static Device_ReadStbResp clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call(clnt, device_readstb, xdr_Device_GenericParms, argp, xdr_Device_ReadStbResp, &clnt_res, TIMEOUT) != RPC_SUCCESS)
+		return (NULL);
+	return (&clnt_res);
+}
+
+Device_Error *
+device_trigger_1(argp, clnt)
+	Device_GenericParms *argp;
+	CLIENT *clnt;
+{
+	static Device_Error clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call(clnt, device_trigger, xdr_Device_GenericParms, argp, xdr_Device_Error, &clnt_res, TIMEOUT) != RPC_SUCCESS)
+		return (NULL);
+	return (&clnt_res);
+}
+
+Device_Error *
+device_clear_1(argp, clnt)
+	Device_GenericParms *argp;
+	CLIENT *clnt;
+{
+	static Device_Error clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call(clnt, device_clear, xdr_Device_GenericParms, argp, xdr_Device_Error, &clnt_res, TIMEOUT) != RPC_SUCCESS)
+		return (NULL);
+	return (&clnt_res);
+}
+
+Device_Error *
+device_remote_1(argp, clnt)
+	Device_GenericParms *argp;
+	CLIENT *clnt;
+{
+	static Device_Error clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call(clnt, device_remote, xdr_Device_GenericParms, argp, xdr_Device_Error, &clnt_res, TIMEOUT) != RPC_SUCCESS)
+		return (NULL);
+	return (&clnt_res);
+}
+
+Device_Error *
+device_local_1(argp, clnt)
+	Device_GenericParms *argp;
+	CLIENT *clnt;
+{
+	static Device_Error clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call(clnt, device_local, xdr_Device_GenericParms, argp, xdr_Device_Error, &clnt_res, TIMEOUT) != RPC_SUCCESS)
+		return (NULL);
+	return (&clnt_res);
+}
+
+Device_Error *
+device_lock_1(argp, clnt)
+	Device_LockParms *argp;
+	CLIENT *clnt;
+{
+	static Device_Error clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call(clnt, device_lock, xdr_Device_LockParms, argp, xdr_Device_Error, &clnt_res, TIMEOUT) != RPC_SUCCESS)
+		return (NULL);
+	return (&clnt_res);
+}
+
+Device_Error *
+device_unlock_1(argp, clnt)
+	Device_Link *argp;
+	CLIENT *clnt;
+{
+	static Device_Error clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call(clnt, device_unlock, xdr_Device_Link, argp, xdr_Device_Error, &clnt_res, TIMEOUT) != RPC_SUCCESS)
+		return (NULL);
+	return (&clnt_res);
+}
+
+Device_Error *
+device_enable_srq_1(argp, clnt)
+	Device_EnableSrqParms *argp;
+	CLIENT *clnt;
+{
+	static Device_Error clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call(clnt, device_enable_srq, xdr_Device_EnableSrqParms, argp, xdr_Device_Error, &clnt_res, TIMEOUT) != RPC_SUCCESS)
+		return (NULL);
+	return (&clnt_res);
+}
+
+Device_DocmdResp *
+device_docmd_1(argp, clnt)
+	Device_DocmdParms *argp;
+	CLIENT *clnt;
+{
+	static Device_DocmdResp clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call(clnt, device_docmd, xdr_Device_DocmdParms, argp, xdr_Device_DocmdResp, &clnt_res, TIMEOUT) != RPC_SUCCESS)
+		return (NULL);
+	return (&clnt_res);
+}
+
+Device_Error *
+destroy_link_1(argp, clnt)
+	Device_Link *argp;
+	CLIENT *clnt;
+{
+	static Device_Error clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call(clnt, destroy_link, xdr_Device_Link, argp, xdr_Device_Error, &clnt_res, TIMEOUT) != RPC_SUCCESS)
+		return (NULL);
+	return (&clnt_res);
+}
+
+Device_Error *
+create_intr_chan_1(argp, clnt)
+	Device_RemoteFunc *argp;
+	CLIENT *clnt;
+{
+	static Device_Error clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call(clnt, create_intr_chan, xdr_Device_RemoteFunc, argp, xdr_Device_Error, &clnt_res, TIMEOUT) != RPC_SUCCESS)
+		return (NULL);
+	return (&clnt_res);
+}
+
+Device_Error *
+destroy_intr_chan_1(argp, clnt)
+	void *argp;
+	CLIENT *clnt;
+{
+	static Device_Error clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call(clnt, destroy_intr_chan, xdr_void, argp, xdr_Device_Error, &clnt_res, TIMEOUT) != RPC_SUCCESS)
+		return (NULL);
+	return (&clnt_res);
+}
+
+void *
+device_intr_srq_1(argp, clnt)
+	Device_SrqParms *argp;
+	CLIENT *clnt;
+{
+	static char clnt_res;
+
+	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call(clnt, device_intr_srq, xdr_Device_SrqParms, argp, xdr_void, &clnt_res, TIMEOUT) != RPC_SUCCESS)
+		return (NULL);
+	return ((void *)&clnt_res);
+}

data/ext/vxi11/vxi11_clnt_linux.inc

@@ -0,0 +1,163 @@
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include <memory.h> /* for memset */
+#include "vxi11.h"
+
+/* Default timeout can be changed using clnt_control() */
+static struct timeval TIMEOUT = { 25, 0 };
+
+enum clnt_stat 
+device_abort_1(Device_Link *argp, Device_Error *clnt_res, CLIENT *clnt)
+{
+	return (clnt_call(clnt, device_abort,
+		(xdrproc_t) xdr_Device_Link, (caddr_t) argp,
+		(xdrproc_t) xdr_Device_Error, (caddr_t) clnt_res,
+		TIMEOUT));
+}
+
+enum clnt_stat 
+create_link_1(Create_LinkParms *argp, Create_LinkResp *clnt_res, CLIENT *clnt)
+{
+	return (clnt_call(clnt, create_link,
+		(xdrproc_t) xdr_Create_LinkParms, (caddr_t) argp,
+		(xdrproc_t) xdr_Create_LinkResp, (caddr_t) clnt_res,
+		TIMEOUT));
+}
+
+enum clnt_stat 
+device_write_1(Device_WriteParms *argp, Device_WriteResp *clnt_res, CLIENT *clnt)
+{
+	return (clnt_call(clnt, device_write,
+		(xdrproc_t) xdr_Device_WriteParms, (caddr_t) argp,
+		(xdrproc_t) xdr_Device_WriteResp, (caddr_t) clnt_res,
+		TIMEOUT));
+}
+
+enum clnt_stat 
+device_read_1(Device_ReadParms *argp, Device_ReadResp *clnt_res, CLIENT *clnt)
+{
+	return (clnt_call(clnt, device_read,
+		(xdrproc_t) xdr_Device_ReadParms, (caddr_t) argp,
+		(xdrproc_t) xdr_Device_ReadResp, (caddr_t) clnt_res,
+		TIMEOUT));
+}
+
+enum clnt_stat 
+device_readstb_1(Device_GenericParms *argp, Device_ReadStbResp *clnt_res, CLIENT *clnt)
+{
+	return (clnt_call(clnt, device_readstb,
+		(xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
+		(xdrproc_t) xdr_Device_ReadStbResp, (caddr_t) clnt_res,
+		TIMEOUT));
+}
+
+enum clnt_stat 
+device_trigger_1(Device_GenericParms *argp, Device_Error *clnt_res, CLIENT *clnt)
+{
+	return (clnt_call(clnt, device_trigger,
+		(xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
+		(xdrproc_t) xdr_Device_Error, (caddr_t) clnt_res,
+		TIMEOUT));
+}
+
+enum clnt_stat 
+device_clear_1(Device_GenericParms *argp, Device_Error *clnt_res, CLIENT *clnt)
+{
+	return (clnt_call(clnt, device_clear,
+		(xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
+		(xdrproc_t) xdr_Device_Error, (caddr_t) clnt_res,
+		TIMEOUT));
+}
+
+enum clnt_stat 
+device_remote_1(Device_GenericParms *argp, Device_Error *clnt_res, CLIENT *clnt)
+{
+	return (clnt_call(clnt, device_remote,
+		(xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
+		(xdrproc_t) xdr_Device_Error, (caddr_t) clnt_res,
+		TIMEOUT));
+}
+
+enum clnt_stat 
+device_local_1(Device_GenericParms *argp, Device_Error *clnt_res, CLIENT *clnt)
+{
+	return (clnt_call(clnt, device_local,
+		(xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
+		(xdrproc_t) xdr_Device_Error, (caddr_t) clnt_res,
+		TIMEOUT));
+}
+
+enum clnt_stat 
+device_lock_1(Device_LockParms *argp, Device_Error *clnt_res, CLIENT *clnt)
+{
+	return (clnt_call(clnt, device_lock,
+		(xdrproc_t) xdr_Device_LockParms, (caddr_t) argp,
+		(xdrproc_t) xdr_Device_Error, (caddr_t) clnt_res,
+		TIMEOUT));
+}
+
+enum clnt_stat 
+device_unlock_1(Device_Link *argp, Device_Error *clnt_res, CLIENT *clnt)
+{
+	return (clnt_call(clnt, device_unlock,
+		(xdrproc_t) xdr_Device_Link, (caddr_t) argp,
+		(xdrproc_t) xdr_Device_Error, (caddr_t) clnt_res,
+		TIMEOUT));
+}
+
+enum clnt_stat 
+device_enable_srq_1(Device_EnableSrqParms *argp, Device_Error *clnt_res, CLIENT *clnt)
+{
+	return (clnt_call(clnt, device_enable_srq,
+		(xdrproc_t) xdr_Device_EnableSrqParms, (caddr_t) argp,
+		(xdrproc_t) xdr_Device_Error, (caddr_t) clnt_res,
+		TIMEOUT));
+}
+
+enum clnt_stat 
+device_docmd_1(Device_DocmdParms *argp, Device_DocmdResp *clnt_res, CLIENT *clnt)
+{
+	return (clnt_call(clnt, device_docmd,
+		(xdrproc_t) xdr_Device_DocmdParms, (caddr_t) argp,
+		(xdrproc_t) xdr_Device_DocmdResp, (caddr_t) clnt_res,
+		TIMEOUT));
+}
+
+enum clnt_stat 
+destroy_link_1(Device_Link *argp, Device_Error *clnt_res, CLIENT *clnt)
+{
+	return (clnt_call(clnt, destroy_link,
+		(xdrproc_t) xdr_Device_Link, (caddr_t) argp,
+		(xdrproc_t) xdr_Device_Error, (caddr_t) clnt_res,
+		TIMEOUT));
+}
+
+enum clnt_stat 
+create_intr_chan_1(Device_RemoteFunc *argp, Device_Error *clnt_res, CLIENT *clnt)
+{
+	return (clnt_call(clnt, create_intr_chan,
+		(xdrproc_t) xdr_Device_RemoteFunc, (caddr_t) argp,
+		(xdrproc_t) xdr_Device_Error, (caddr_t) clnt_res,
+		TIMEOUT));
+}
+
+enum clnt_stat 
+destroy_intr_chan_1(void *argp, Device_Error *clnt_res, CLIENT *clnt)
+{
+	return (clnt_call(clnt, destroy_intr_chan,
+		(xdrproc_t) xdr_void, (caddr_t) argp,
+		(xdrproc_t) xdr_Device_Error, (caddr_t) clnt_res,
+		TIMEOUT));
+}
+
+enum clnt_stat 
+device_intr_srq_1(Device_SrqParms *argp, void *clnt_res, CLIENT *clnt)
+{
+	return (clnt_call(clnt, device_intr_srq,
+		(xdrproc_t) xdr_Device_SrqParms, (caddr_t) argp,
+		(xdrproc_t) xdr_void, (caddr_t) clnt_res,
+		TIMEOUT));
+}