cpython/Modules/_xdrmodule.c

168 lines
3.9 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* This module exports part of the C API to the XDR routines into Python.
* XDR is Sun's eXternal Data Representation, as described in RFC 1014. This
* module is used by xdrlib.py to support the float and double data types
* which are too much of a pain to support in Python directly. It is
* not required by xdrlib.py -- when not available, these types aren't
* supported at the Python layer. Note that representations that can be
* implemented solely in Python, are *not* reproduced here.
*
* Module version number: 1.0
*
* See xdrlib.py for usage notes.
*
* Note: this has so far, only been tested on Solaris 2.5 and SGI IRIX 5.3.
* On these systems, you will need to link with -lnsl for these
* symbols to be defined.
*/
#include "Python.h"
#include <netconfig.h>
#include <rpc/rpc.h>
#include <rpc/xdr.h>
static PyObject* xdr_error;
static PyObject*
pack_float(self, args)
PyObject* self;
PyObject* args;
{
XDR xdr;
float value;
union { /* guarantees proper alignment */
long dummy;
char buffer[4];
} addr;
PyObject* rtn = NULL;
if (!PyArg_ParseTuple(args, "f", &value))
return NULL;
xdrmem_create(&xdr, addr.buffer, 4, XDR_ENCODE);
if (xdr_float(&xdr, &value))
rtn = PyString_FromStringAndSize(addr.buffer, 4);
else
PyErr_SetString(xdr_error, "conversion from float failed");
xdr_destroy(&xdr);
return rtn;
}
static PyObject*
pack_double(self, args)
PyObject* self;
PyObject* args;
{
XDR xdr;
double value;
union { /* guarantees proper alignment */
long dummy;
char buffer[8];
} addr;
PyObject* rtn = NULL;
if (!PyArg_ParseTuple(args, "d", &value))
return NULL;
xdrmem_create(&xdr, addr.buffer, 8, XDR_ENCODE);
if (xdr_double(&xdr, &value))
rtn = PyString_FromStringAndSize(addr.buffer, 8);
else
PyErr_SetString(xdr_error, "conversion from double failed");
xdr_destroy(&xdr);
return rtn;
}
static PyObject*
unpack_float(self, args)
PyObject* self;
PyObject* args;
{
XDR xdr;
float value;
char* string;
int strlen;
PyObject* rtn = NULL;
if (!PyArg_ParseTuple(args, "s#", &string, &strlen))
return NULL;
if (strlen != 4) {
PyErr_SetString(PyExc_ValueError, "4 byte string expected");
return NULL;
}
/* Python guarantees that the string is 4 byte aligned */
xdrmem_create(&xdr, (caddr_t)string, 4, XDR_DECODE);
if (xdr_float(&xdr, &value))
rtn = Py_BuildValue("f", value);
else
PyErr_SetString(xdr_error, "conversion to float failed");
xdr_destroy(&xdr);
return rtn;
}
static PyObject*
unpack_double(self, args)
PyObject* self;
PyObject* args;
{
XDR xdr;
double value;
char* string;
int strlen;
PyObject* rtn;
if (!PyArg_ParseTuple(args, "s#", &string, &strlen))
return NULL;
if (strlen != 8) {
PyErr_SetString(PyExc_ValueError, "8 byte string expected");
return NULL;
}
/* Python guarantees that the string is 4 byte aligned */
xdrmem_create(&xdr, (caddr_t)string, 8, XDR_DECODE);
if (xdr_double(&xdr, &value))
rtn = Py_BuildValue("d", value);
else
PyErr_SetString(xdr_error, "conversion to double failed");
xdr_destroy(&xdr);
return rtn;
}
static struct PyMethodDef
xdr_methods[] = {
{"pack_float", pack_float, 1},
{"pack_double", pack_double, 1},
{"unpack_float", unpack_float, 1},
{"unpack_double", unpack_double, 1},
{NULL, NULL, 0} /* sentinel */
};
void
init_xdr()
{
PyObject* module;
PyObject* dict;
module = Py_InitModule("_xdr", xdr_methods);
dict = PyModule_GetDict(module);
xdr_error = PyString_FromString("_xdr.error");
PyDict_SetItemString(dict, "error", xdr_error);
}