int OggFlacDecoder_init(decoders_OggFlacDecoder *self, PyObject *args, PyObject *kwds) { char* filename; ogg_status result; uint16_t header_packets; self->ogg_stream = NULL; self->ogg_file = NULL; self->subframe_data = aa_int_new(); self->residuals = a_int_new(); self->qlp_coeffs = a_int_new(); self->framelist_data = a_int_new(); self->audiotools_pcm = NULL; self->packet = br_substream_new(BS_BIG_ENDIAN); self->stream_finalized = 0; if (!PyArg_ParseTuple(args, "si", &filename, &(self->channel_mask))) return -1; if (self->channel_mask < 0) { PyErr_SetString(PyExc_ValueError, "channel_mask must be >= 0"); return -1; } self->ogg_file = fopen(filename, "rb"); if (self->ogg_file == NULL) { PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename); return -1; } else { self->ogg_stream = oggreader_open(self->ogg_file); } /*the first packet should be the FLAC's STREAMINFO*/ if ((result = oggreader_next_packet(self->ogg_stream, self->packet)) == OGG_OK) { if (!oggflac_read_streaminfo(self->packet, &(self->streaminfo), &header_packets)) return -1; } else { PyErr_SetString(ogg_exception(result), ogg_strerror(result)); return -1; } /*skip subsequent header packets*/ for (; header_packets > 0; header_packets--) { if ((result = oggreader_next_packet(self->ogg_stream, self->packet)) != OGG_OK) { PyErr_SetString(ogg_exception(result), ogg_strerror(result)); return -1; } } /*initialize the output MD5 sum*/ audiotools__MD5Init(&(self->md5)); /*add callback for CRC16 calculation*/ br_add_callback(self->packet, (bs_callback_f)flac_crc16, &(self->crc16)); /*setup a framelist generator function*/ if ((self->audiotools_pcm = open_audiotools_pcm()) == NULL) return -1; /*mark stream as not closed and ready for reading*/ self->closed = 0; return 0; }
static PyObject *_listdir(char *path, int pathlen, int keepstat, char *skip) { PyObject *list, *elem, *stat, *ret = NULL; char fullpath[PATH_MAX + 10]; int kind, err; struct stat st; struct dirent *ent; DIR *dir; #ifdef AT_SYMLINK_NOFOLLOW int dfd = -1; #endif if (pathlen >= PATH_MAX) { PyErr_SetString(PyExc_ValueError, "path too long"); goto error_value; } strncpy(fullpath, path, PATH_MAX); fullpath[pathlen] = '/'; #ifdef AT_SYMLINK_NOFOLLOW dfd = open(path, O_RDONLY); if (dfd == -1) { PyErr_SetFromErrnoWithFilename(PyExc_OSError, path); goto error_value; } dir = fdopendir(dfd); #else dir = opendir(path); #endif if (!dir) { PyErr_SetFromErrnoWithFilename(PyExc_OSError, path); goto error_dir; } list = PyList_New(0); if (!list) goto error_list; while ((ent = readdir(dir))) { if (!strcmp(ent->d_name, ".") || !strcmp(ent->d_name, "..")) continue; kind = entkind(ent); if (kind == -1 || keepstat) { #ifdef AT_SYMLINK_NOFOLLOW err = fstatat(dfd, ent->d_name, &st, AT_SYMLINK_NOFOLLOW); #else strncpy(fullpath + pathlen + 1, ent->d_name, PATH_MAX - pathlen); fullpath[PATH_MAX] = 0; err = lstat(fullpath, &st); #endif if (err == -1) { strncpy(fullpath + pathlen + 1, ent->d_name, PATH_MAX - pathlen); fullpath[PATH_MAX] = 0; PyErr_SetFromErrnoWithFilename(PyExc_OSError, fullpath); goto error; } kind = st.st_mode & S_IFMT; } /* quit early? */ if (skip && kind == S_IFDIR && !strcmp(ent->d_name, skip)) { ret = PyList_New(0); goto error; } if (keepstat) { stat = PyObject_CallObject((PyObject *)&listdir_stat_type, NULL); if (!stat) goto error; memcpy(&((struct listdir_stat *)stat)->st, &st, sizeof(st)); elem = Py_BuildValue("siN", ent->d_name, kind, stat); } else elem = Py_BuildValue("si", ent->d_name, kind); if (!elem) goto error; PyList_Append(list, elem); Py_DECREF(elem); } ret = list; Py_INCREF(ret); error: Py_DECREF(list); error_list: closedir(dir); error_dir: #ifdef AT_SYMLINK_NOFOLLOW close(dfd); #endif error_value: return ret; }
/** Find the executable, argument list and environment * * This will also fill in the command attribute. * * The sysctl calls here don't use a wrapper as in darwin_prcesstable.c since * they know the size of the returned structure already. * * The layout of the raw argument space is documented in start.s, which is * part of the Csu project. In summary, it looks like: * * XXX: This layout does not match whith what the code does. The code seems * to think exec_path is in between the first argc and arg[0], also the data * returned by ssyctl() seems to be starting at the first argc according to * the code. * * /---------------\ 0x00000000 * : : * : : * |---------------| * | argc | * |---------------| * | arg[0] | * |---------------| * : : * : : * |---------------| * | arg[argc - 1] | * |---------------| * | 0 | * |---------------| * | env[0] | * |---------------| * : : * : : * |---------------| * | env[n] | * |---------------| * | 0 | * |---------------| <-- Beginning of data returned by sysctl() is here. * | argc | * |---------------| * | exec_path | * |:::::::::::::::| * | | * | String area. | * | | * |---------------| <-- Top of stack. * : : * : : * \---------------/ 0xffffffff */ static int set_exe(struct psi_process *proci, struct kinfo_proc *p) { int mib[3], argmax, nargs; size_t size; char *procargs, *cp; int i; int env_start = 0; /* Get the maximum process arguments size. */ mib[0] = CTL_KERN; mib[1] = KERN_ARGMAX; size = sizeof(argmax); if (sysctl(mib, 2, &argmax, &size, NULL, 0) == -1) { PyErr_SetFromErrnoWithFilename(PyExc_OSError, "sysctl() argmax"); return -1; } /* Allocate space for the arguments. */ procargs = (char *)psi_malloc(argmax); if (procargs == NULL) return -1; /* Make a sysctl() call to get the raw argument space of the process. */ mib[0] = CTL_KERN; mib[1] = KERN_PROCARGS2; mib[2] = p->kp_proc.p_pid; size = (size_t)argmax; if (sysctl(mib, 3, procargs, &size, NULL, 0) == -1) { /* We failed to get the exe info, but it's not fatal. We probably just * didn't have permission to access the KERN_PROCARGS2 for this * process. */ psi_free(procargs); proci->exe_status = PSI_STATUS_PRIVS; proci->argc_status = PSI_STATUS_PRIVS; proci->argv_status = PSI_STATUS_PRIVS; proci->envc_status = PSI_STATUS_PRIVS; proci->envv_status = PSI_STATUS_PRIVS; proci->command_status = PSI_STATUS_PRIVS; return 0; } memcpy(&nargs, procargs, sizeof(nargs)); cp = procargs + sizeof(nargs); /* Save the exe */ proci->exe = psi_strdup(cp); if (proci->exe == NULL) { psi_free(procargs); return -1; } proci->exe_status = PSI_STATUS_OK; /* Skip over the exe. */ cp += strlen(cp); if (cp == &procargs[size]) { psi_free(procargs); PyErr_SetString(PyExc_OSError, "Did not find args and env"); return -1; } /* Skip trailing '\0' characters. */ for (; cp < &procargs[size]; cp++) { if (*cp != '\0') { /* Beginning of first argument reached. */ break; } } if (cp == &procargs[size]) { psi_free(procargs); /* We dont' have any arguments or environment */ if (nargs == 0) { proci->argc = 0; proci->argc_status = PSI_STATUS_OK; proci->argv = NULL; proci->argv_status = PSI_STATUS_OK; proci->envc = 0; proci->envc_status = PSI_STATUS_OK; proci->envv = NULL; proci->envv_status = PSI_STATUS_OK; /* Update proci->command */ if (command_from_argv(&proci->command, proci->argv, proci->argc) < 0) { psi_free(procargs); return -1; } proci->command_status = PSI_STATUS_OK; return 0; } else { PyErr_SetString(PyExc_OSError, "Did not find args and env"); return -1; } } /* The argument list */ proci->argc = nargs; proci->argc_status = PSI_STATUS_OK; proci->argv = psi_strings_to_array(cp, nargs); if (proci->argv == NULL) { psi_free(procargs); return -1; } proci->argv_status = PSI_STATUS_OK; if (command_from_argv(&proci->command, proci->argv, proci->argc) < 0) { psi_free(procargs); return -1; } proci->command_status = PSI_STATUS_OK; /* The environment */ for (i = 0; i < nargs; i++) { env_start += strlen(proci->argv[i])+1; } env_start--; proci->envc = 0; for (i = 0; ; i++) { if (*(cp+env_start + i) == '\0') { if (*(cp+env_start + i + 1) == '\0') break; else proci->envc++; } } proci->envc_status = PSI_STATUS_OK; proci->envv = psi_strings_to_array(cp+env_start+1, proci->envc); psi_free(procargs); if (proci->envv == NULL) return -1; proci->envv_status = PSI_STATUS_OK; return 0; }
int DVDA_Title_init(decoders_DVDA_Title *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = {"audio_ts", "titleset", "start_sector", "end_sector", "cdrom", NULL}; char* audio_ts; unsigned titleset; unsigned start_sector; unsigned end_sector; #else int DVDA_Title_init(decoders_DVDA_Title *self, char* audio_ts, unsigned titleset, unsigned start_sector, unsigned end_sector) { #endif char* cdrom = NULL; self->sector_reader = NULL; self->packet_reader = NULL; self->packet_data = buf_new(); self->frames = buf_new(); self->pcm_frames_remaining = 0; self->bits_per_sample = 0; self->sample_rate = 0; self->channel_count = 0; self->channel_mask = 0; self->mlp_decoder = open_mlp_decoder(self->frames); self->codec_framelist = aa_int_new(); self->output_framelist = aa_int_new(); #ifndef STANDALONE if ((self->audiotools_pcm = open_audiotools_pcm()) == NULL) return -1; if (!PyArg_ParseTupleAndKeywords(args, kwds, "sIII|s", kwlist, &audio_ts, &titleset, &start_sector, &end_sector, &cdrom)) return -1; #endif /*setup a sector reader according to AUDIO_TS and cdrom device*/ if ((self->sector_reader = open_sector_reader(audio_ts, titleset, cdrom)) == NULL) { #ifndef STANDALONE PyErr_SetFromErrnoWithFilename(PyExc_IOError, audio_ts); #endif return -1; } /*setup a packet reader according to start and end sector this packet reader will be shared by all returned DVDA_Tracks*/ self->packet_reader = open_packet_reader(self->sector_reader, start_sector, end_sector); return 0; }
static oss_audio_t * newossobject(PyObject *arg) { oss_audio_t *self; int fd, afmts, imode; char *basedev = NULL; char *mode = NULL; /* Two ways to call open(): open(device, mode) (for consistency with builtin open()) open(mode) (for backwards compatibility) because the *first* argument is optional, parsing args is a wee bit tricky. */ if (!PyArg_ParseTuple(arg, "s|s:open", &basedev, &mode)) return NULL; if (mode == NULL) { /* only one arg supplied */ mode = basedev; basedev = NULL; } if (strcmp(mode, "r") == 0) imode = O_RDONLY; else if (strcmp(mode, "w") == 0) imode = O_WRONLY; else if (strcmp(mode, "rw") == 0) imode = O_RDWR; else { PyErr_SetString(OSSAudioError, "mode must be 'r', 'w', or 'rw'"); return NULL; } /* Open the correct device: either the 'device' argument, or the AUDIODEV environment variable, or "/dev/dsp". */ if (basedev == NULL) { /* called with one arg */ basedev = getenv("AUDIODEV"); if (basedev == NULL) /* $AUDIODEV not set */ basedev = "/dev/dsp"; } /* Open with O_NONBLOCK to avoid hanging on devices that only allow one open at a time. This does *not* affect later I/O; OSS provides a special ioctl() for non-blocking read/write, which is exposed via oss_nonblock() below. */ if ((fd = open(basedev, imode|O_NONBLOCK)) == -1) { PyErr_SetFromErrnoWithFilename(PyExc_IOError, basedev); return NULL; } /* And (try to) put it back in blocking mode so we get the expected write() semantics. */ if (fcntl(fd, F_SETFL, 0) == -1) { close(fd); PyErr_SetFromErrnoWithFilename(PyExc_IOError, basedev); return NULL; } if (ioctl(fd, SNDCTL_DSP_GETFMTS, &afmts) == -1) { PyErr_SetFromErrnoWithFilename(PyExc_IOError, basedev); return NULL; } /* Create and initialize the object */ if ((self = PyObject_New(oss_audio_t, &OSSAudioType)) == NULL) { close(fd); return NULL; } self->fd = fd; self->mode = imode; self->icount = self->ocount = 0; self->afmts = afmts; return self; }
/* * Return what CPU the process is running on. */ static PyObject * psutil_proc_cpu_num(PyObject *self, PyObject *args) { int fd = NULL; int pid; char path[1000]; struct prheader header; struct lwpsinfo *lwp; char *lpsinfo = NULL; char *ptr = NULL; int nent; int size; int proc_num; size_t nbytes; const char *procfs_path; if (! PyArg_ParseTuple(args, "is", &pid, &procfs_path)) return NULL; sprintf(path, "%s/%i/lpsinfo", procfs_path, pid); fd = open(path, O_RDONLY); if (fd == -1) { PyErr_SetFromErrnoWithFilename(PyExc_OSError, path); return NULL; } // read header nbytes = pread(fd, &header, sizeof(header), 0); if (nbytes == -1) { PyErr_SetFromErrno(PyExc_OSError); goto error; } if (nbytes != sizeof(header)) { PyErr_SetString( PyExc_RuntimeError, "read() file structure size mismatch"); goto error; } // malloc nent = header.pr_nent; size = header.pr_entsize * nent; ptr = lpsinfo = malloc(size); if (lpsinfo == NULL) { PyErr_NoMemory(); goto error; } // read the rest nbytes = pread(fd, lpsinfo, size, sizeof(header)); if (nbytes == -1) { PyErr_SetFromErrno(PyExc_OSError); goto error; } if (nbytes != size) { PyErr_SetString( PyExc_RuntimeError, "read() file structure size mismatch"); goto error; } // done lwp = (lwpsinfo_t *)ptr; proc_num = lwp->pr_onpro; close(fd); free(ptr); free(lpsinfo); return Py_BuildValue("i", proc_num); error: if (fd != -1) close(fd); if (ptr != NULL) free(ptr); if (lpsinfo != NULL) free(lpsinfo); return NULL; }
static PyObject * open_the_file(PyFileObject *f, char *name, char *mode) { assert(f != NULL); assert(PyFile_Check(f)); assert(name != NULL); assert(mode != NULL); assert(f->f_fp == NULL); /* rexec.py can't stop a user from getting the file() constructor -- all they have to do is get *any* file object f, and then do type(f). Here we prevent them from doing damage with it. */ if (PyEval_GetRestricted()) { PyErr_SetString(PyExc_IOError, "file() constructor not accessible in restricted mode"); return NULL; } errno = 0; #ifdef HAVE_FOPENRF if (*mode == '*') { FILE *fopenRF(); f->f_fp = fopenRF(name, mode+1); } else #endif { Py_BEGIN_ALLOW_THREADS f->f_fp = fopen(name, mode); Py_END_ALLOW_THREADS } if (f->f_fp == NULL) { #ifdef NO_FOPEN_ERRNO /* Metroworks only, wich does not always sets errno */ if (errno == 0) { PyObject *v; v = Py_BuildValue("(is)", 0, "Cannot open file"); if (v != NULL) { PyErr_SetObject(PyExc_IOError, v); Py_DECREF(v); } return NULL; } #endif #ifdef _MSC_VER /* MSVC 6 (Microsoft) leaves errno at 0 for bad mode strings, * across all Windows flavors. When it sets EINVAL varies * across Windows flavors, the exact conditions aren't * documented, and the answer lies in the OS's implementation * of Win32's CreateFile function (whose source is secret). * Seems the best we can do is map EINVAL to ENOENT. */ if (errno == 0) /* bad mode string */ errno = EINVAL; else if (errno == EINVAL) /* unknown, but not a mode string */ errno = ENOENT; #endif if (errno == EINVAL) PyErr_Format(PyExc_IOError, "invalid mode: %s", mode); else PyErr_SetFromErrnoWithFilename(PyExc_IOError, name); f = NULL; } return (PyObject *)f; }
static PyObject * AMC_fromFile (AMC *self, PyObject *args) { char *filename; GIOChannel *file; AMC *motion; gchar *line; int terminator; guint64 current_frame, total_frames; GSList *bones = NULL; GSList *dofs = NULL; GSList *data = NULL; GSList *i, *j; float *f; PyArrayObject *pao; // get filename if (!PyArg_ParseTuple (args, "s;expected 'string'", &filename)) return NULL; file = g_io_channel_new_file (filename, "r", NULL); if (file == NULL) { // FIXME - we should be using the GError, not errno return PyErr_SetFromErrnoWithFilename (PyExc_IOError, filename); } motion = (AMC *) CreateAMC (); // first pass - go through, grab comments & format, parse first frame // to find #dof for each bone, total number of frames while (g_io_channel_read_line (file, &line, NULL, &terminator, NULL) == G_IO_STATUS_NORMAL) { // get rid of line terminator line[terminator] = '\0'; // parse data if (line[0] == '#') { // comment PyObject *string = PyString_FromString (line); PyList_Append (motion->comments, string); Py_DECREF (string); } else if (line[0] == ':') { // format specifier PyObject *string = PyString_FromString (line); PyList_Append (motion->format, string); Py_DECREF (string); } else { gchar *ch; gboolean newframe = TRUE; g_strstrip (line); // empty line? if (strlen (line) == 0) continue; // determine if this line just contains an int - if so, it's // the beginning of a new frame for (ch = line; *ch; ch++) { if (!g_ascii_isdigit (*ch)) { newframe = FALSE; break; } } if (newframe) { current_frame = g_ascii_strtoull (line, NULL, 10); } else { if (current_frame == 1) { gchar **tokens = g_strsplit (line, " ", 0); guint token; guint dof = 0; g_strstrip (tokens[0]); for (token = 1; tokens[token]; token++) { g_strstrip (tokens[token]); if (strlen (tokens[token])) dof++; } // create two lists, one with the names of the bones (so we // know what order things go in), the other with the number // of dofs for each bone bones = g_slist_append (bones, g_strdup (tokens[0])); dofs = g_slist_append (dofs, GUINT_TO_POINTER (dof)); g_strfreev (tokens); } } } g_free (line); } total_frames = current_frame; // allocate Numeric arrays for (i = dofs; i; i = g_slist_next (i)) { int dims[2]; guint dof = GPOINTER_TO_UINT (i->data); PyObject *array; dims[0] = total_frames; dims[1] = dof; array = PyArray_FromDims (2, dims, PyArray_FLOAT); data = g_slist_append (data, array); } g_io_channel_seek_position (file, 0, G_SEEK_SET, NULL); // second pass - read in all the data, now that we have space allocated for it while (g_io_channel_read_line (file, &line, NULL, &terminator, NULL) == G_IO_STATUS_NORMAL) { // get rid of line terminator line[terminator] = '\0'; // parse data if (line[0] == '#' || line[0] == ':') { // we read these in during the first pass. ignore continue; } else { gchar *ch; gboolean newframe = TRUE; g_strstrip (line); // empty line ? if (strlen (line) == 0) continue; // determine if this line just contains an int - if so, it's // the beginning of a new frame for (ch = line; *ch; ch++) { if (!g_ascii_isdigit (*ch)) { newframe = FALSE; break; } } if (newframe) { current_frame = g_ascii_strtoull (line, NULL, 10) - 1; i = data; pao = i->data; } else { gchar **tokens = g_strsplit (line, " ", 0); guint token, dof = 0; g_strstrip (tokens[0]); for (token = 1; tokens[token]; token++) { g_strstrip (tokens[token]); if (strlen (tokens[token])) { f = (float *) (pao->data + (current_frame * pao->strides[0]) + (dof * pao->strides[1])); *f = (float) g_ascii_strtod (tokens[token], NULL); } dof++; } g_strfreev (tokens); i = g_slist_next (i); if (i != NULL) { pao = i->data; } } } g_free (line); } for (i = data, j = bones; i; i = g_slist_next (i), j = g_slist_next (j)) { PyObject *key = PyString_FromString (j->data); PyDict_SetItem (motion->bones, key, i->data); } g_slist_foreach (bones, (GFunc) g_free, NULL); g_slist_free (bones); g_slist_free (dofs); g_slist_free (data); g_io_channel_shutdown (file, FALSE, NULL); g_io_channel_unref (file); return (PyObject *) motion; }
static PyObject * _cracklib_FascistCheck(PyObject *self, PyObject *args, PyObject *kwargs) { char *candidate, *dict; char *defaultdict = NULL; const char *result; struct stat st; char *keywords[] = {"pw", "dictpath", NULL}; char *dictfile; self = NULL; candidate = NULL; dict = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|s", keywords, &candidate, &dict)) { PyErr_SetString(PyExc_ValueError, "error parsing arguments"); return NULL; } if (candidate == NULL) { PyErr_SetString(PyExc_ValueError, "first argument was not a string!"); return NULL; } if (dict != NULL) { if (dict[0] != '/') { PyErr_SetString(PyExc_ValueError, "second argument was not an absolute path!"); return NULL; } dictfile = malloc(strlen(dict) + sizeof(DICT_SUFFIX)); if (dictfile == NULL) { PyErr_SetFromErrnoWithFilename(PyExc_OSError, dict); return NULL; } sprintf(dictfile, "%s" DICT_SUFFIX, dict); if (lstat(dictfile, &st) == -1) { PyErr_SetFromErrnoWithFilename(PyExc_OSError, dictfile); free(dictfile); return NULL; } free(dictfile); } else { defaultdict = strdup(GetDefaultCracklibDict()); if (errno == ENOMEM) { PyErr_SetFromErrno(PyExc_OSError); return NULL; } dictfile = malloc(strlen(defaultdict) + sizeof(DICT_SUFFIX)); if (dictfile == NULL) { PyErr_SetFromErrnoWithFilename(PyExc_OSError, defaultdict); free(defaultdict); return NULL; } sprintf(dictfile, "%s" DICT_SUFFIX, defaultdict); if (lstat(dictfile, &st) == -1) { PyErr_SetFromErrnoWithFilename(PyExc_OSError, dictfile); free(defaultdict); free(dictfile); return NULL; } free(dictfile); } setlocale(LC_ALL, ""); #ifdef ENABLE_NLS textdomain("cracklib"); #endif LOCK(); result = FascistCheck(candidate, dict ? dict : defaultdict); UNLOCK(); if (defaultdict != NULL) { free(defaultdict); } if (result != NULL) { PyErr_SetString(PyExc_ValueError, result); return NULL; } return Py_BuildValue("s", candidate); }
/* Function of no arguments returning new Data object */ static PyObject * open_file(PyObject *self, PyObject *args) { char *filename; int fd; DataObject *data_obj; unsigned char file_hdr[2], jpeg_hdr[2] = {0xff,0xd8}; if (!PyArg_ParseTuple(args, "s:new", &filename)) return NULL; /* check if the file exists first. We close this fd just * because, but maybe in the future there is a case for * keeping it around. */ fd = open(filename, O_RDONLY); if (fd < 0) return PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename); /* read the first 2 bytes, and check it looks like a jpeg */ if (read(fd, file_hdr, 2) < 2) { close(fd); return PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename); } if (memcmp(jpeg_hdr, file_hdr, 2) != 0) { close(fd); PyErr_SetString(PyExc_ValueError, "This file does not appear to be a JPEG file\n"); return NULL; } close(fd); data_obj = newDataObject(args); if (data_obj == NULL) return PyErr_NoMemory(); /* save the filename for later */ data_obj->filename = PyString_FromString(filename); if (!data_obj->filename) { Py_DECREF(data_obj); return PyErr_NoMemory(); } /* firstly, try and get the existing data */ data_obj->d = iptc_data_new_from_jpeg(filename); if (data_obj->d) { /* read the existing iptc data into the dataset objects */ int i; for (i=0; i < data_obj->d->count; i++) { IptcDataSet *e = data_obj->d->datasets[i]; DataSetObject *ds = newDataSetObject(e); /* XXX bail out? */ /* dataset objects hold a reference to their * parent dataobject */ ds->parent = data_obj; Py_INCREF(data_obj); ds->state = VALID; PyList_Append(data_obj->DataSet_list, (PyObject *)ds); } } else { /* create a new, empty data object */ data_obj->d = iptc_data_new(); if (!data_obj->d) return PyErr_NoMemory(); } data_obj->state = OPEN; return (PyObject*)data_obj; }
int Command_build(twopence_Command *self, twopence_command_t *cmd) { twopence_buf_t *buffer = NULL; twopence_command_init(cmd, self->command); cmd->user = self->user; cmd->timeout = self->timeout; cmd->request_tty = self->useTty; cmd->background = self->background; twopence_command_ostreams_reset(cmd); if (self->quiet || self->stdout == Py_None) { /* ostream has already been reset above */ } else { /* Copy remote stdout to our stdout */ twopence_command_iostream_redirect(cmd, TWOPENCE_STDOUT, 1, false); } if (!Command_redirect_iostream(cmd, TWOPENCE_STDOUT, self->stdout, &buffer)) return -1; if (self->quiet || self->stderr == Py_None) { /* ostream has already been reset above */ } else { /* Copy remote stderr to our stderr */ twopence_command_iostream_redirect(cmd, TWOPENCE_STDERR, 2, false); } /* If cmd.stdout and cmd.stderr are both NULL, or both refer to the same * bytearray object, send the remote stdout and stderr to a shared buffer */ if (buffer && self->stderr == self->stdout) { twopence_command_ostream_capture(cmd, TWOPENCE_STDERR, buffer); } else if (!Command_redirect_iostream(cmd, TWOPENCE_STDERR, self->stderr, NULL)) { return -1; } if (self->stdinPath != NULL) { int fd = open(self->stdinPath, O_RDONLY); if (fd < 0) { PyErr_SetFromErrnoWithFilename(PyExc_IOError, self->stdinPath); return -1; } twopence_command_iostream_redirect(cmd, TWOPENCE_STDIN, fd, true); } else if (self->stdin) { if (!Command_redirect_iostream(cmd, TWOPENCE_STDIN, self->stdin, NULL)) return -1; } else if (!self->background) { /* Eric wants us to pipe stdin into the command by default */ FILE *fp; int fd; fp = PySys_GetFile("stdin", NULL); if (fp != NULL) { if ((fd = fileno(fp)) < 0) { PyErr_SetString(PyExc_SystemError, "cannot connect command to stdin (not a regular file)"); return -1; } /* We dup() the file descriptor so that we no longer have to worry * about what python does with its File object */ twopence_command_iostream_redirect(cmd, TWOPENCE_STDIN, dup(fd), true); } } /* Copy all environment variables */ if (self->environ.count) twopence_env_copy(&cmd->env, &self->environ); return 0; }
psi_mountlist_t * psi_arch_mountlist(const int remote) { FILE *mntent; struct mntent mnt; char buf[PATH_MAX * 3]; /* size used in autofs so I hope it's okay */ psi_mountlist_t *ml = NULL; psi_mountinfo_t *mounti, **mounts; /* Open /etc/mtab */ mntent = setmntent(_PATH_MOUNTED, "r"); if (mntent == NULL) return (psi_mountlist_t *) PyErr_SetFromErrnoWithFilename( PyExc_OSError, _PATH_MOUNTED); /* Create our (empty) mountlist */ ml = (psi_mountlist_t *)psi_calloc(sizeof(psi_mountlist_t)); if (ml == NULL) { fclose(mntent); return NULL; } /* Step through each line in the mount file */ while (getmntent_r(mntent, &mnt, buf, sizeof(buf)) != NULL) { /* Skip remote filesystems if not asked for them */ if (!remote && (strchr(mnt.mnt_fsname, ':') != NULL || strncmp(mnt.mnt_fsname, "//", 2) == 0)) continue; /* Allocate space for the mount information */ if ((mounti = psi_calloc(sizeof(psi_mountinfo_t))) == NULL) { fclose(mntent); psi_free_mountlist(ml); return NULL; } /* And then allocate more space for the mount list */ mounts = (psi_mountinfo_t **)psi_realloc( ml->mounts, (ml->count + 1) * sizeof(psi_mountinfo_t *)); if (mounts == NULL) { fclose(mntent); psi_free_mountinfo(mounti); psi_free_mountlist(ml); return NULL; } ml->mounts = mounts; ml->mounts[ml->count] = mounti; ml->count += 1; /* Finally add the information to mounti */ if (set_mntent(mounti, &mnt) < 0) { fclose(mntent); psi_free_mountlist(ml); return NULL; } if (posix_set_vfs(mounti) < 0) { fclose(mntent); psi_free_mountlist(ml); return NULL; } } if (!feof(mntent)) { /* Uh oh, we had a read error */ endmntent(mntent); psi_free_mountlist(ml); PyErr_Format(PyExc_OSError, "Read error in %s", _PATH_MOUNTED); return NULL; } endmntent(mntent); return ml; }
static PyObject * _psp_module_parse(PyObject *self, PyObject *argv) { PyObject *code; char *filename; char *dir = NULL; char *path; psp_parser_t *parser; yyscan_t scanner; FILE *f; if (!PyArg_ParseTuple(argv, "s|s", &filename, &dir)) { return NULL; } if (dir) { path = malloc(strlen(filename)+strlen(dir)+1); if (!path) return PyErr_NoMemory(); strcpy(path, dir); strcat(path, filename); } else { path = filename; } Py_BEGIN_ALLOW_THREADS f = fopen(path, "rb"); Py_END_ALLOW_THREADS if (f == NULL) { PyErr_SetFromErrnoWithFilename(PyExc_IOError, path); if (dir) free(path); return NULL; } if (dir) free(path); parser = psp_parser_init(); if (dir) parser->dir = dir; yylex_init(&scanner); yyset_in(f, scanner); yyset_extra(parser, scanner); yylex(scanner); yylex_destroy(scanner); fclose(f); psp_string_0(&parser->pycode); if (PyErr_Occurred()) { psp_parser_cleanup(parser); return NULL; } if (parser->pycode.blob) { code = MpBytesOrUnicode_FromString(parser->pycode.blob); } else { code = MpBytesOrUnicode_FromString(""); } psp_parser_cleanup(parser); return code; }
static PyObject *posixfile(PyObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = {"name", "mode", "buffering", NULL}; PyObject *file_obj = NULL; char *name = NULL; char *mode = "rb"; DWORD access = 0; DWORD creation; HANDLE handle; int fd, flags = 0; int bufsize = -1; char m0, m1, m2; char fpmode[4]; int fppos = 0; int plus; FILE *fp; if (!PyArg_ParseTupleAndKeywords(args, kwds, "et|si:posixfile", kwlist, Py_FileSystemDefaultEncoding, &name, &mode, &bufsize)) return NULL; m0 = mode[0]; m1 = m0 ? mode[1] : '\0'; m2 = m1 ? mode[2] : '\0'; plus = m1 == '+' || m2 == '+'; fpmode[fppos++] = m0; if (m1 == 'b' || m2 == 'b') { flags = _O_BINARY; fpmode[fppos++] = 'b'; } else flags = _O_TEXT; if (plus) { flags |= _O_RDWR; access = GENERIC_READ | GENERIC_WRITE; fpmode[fppos++] = '+'; } fpmode[fppos++] = '\0'; switch (m0) { case 'r': creation = OPEN_EXISTING; if (!plus) { flags |= _O_RDONLY; access = GENERIC_READ; } break; case 'w': creation = CREATE_ALWAYS; if (!plus) { access = GENERIC_WRITE; flags |= _O_WRONLY; } break; case 'a': creation = OPEN_ALWAYS; flags |= _O_APPEND; if (!plus) { flags |= _O_WRONLY; access = GENERIC_WRITE; } break; default: PyErr_Format(PyExc_ValueError, "mode string must begin with one of 'r', 'w', " "or 'a', not '%c'", m0); goto bail; } handle = CreateFile(name, access, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, creation, FILE_ATTRIBUTE_NORMAL, 0); if (handle == INVALID_HANDLE_VALUE) { PyErr_SetFromWindowsErrWithFilename(GetLastError(), name); goto bail; } fd = _open_osfhandle((intptr_t)handle, flags); if (fd == -1) { CloseHandle(handle); PyErr_SetFromErrnoWithFilename(PyExc_IOError, name); goto bail; } #ifndef IS_PY3K fp = _fdopen(fd, fpmode); if (fp == NULL) { _close(fd); PyErr_SetFromErrnoWithFilename(PyExc_IOError, name); goto bail; } file_obj = PyFile_FromFile(fp, name, mode, fclose); if (file_obj == NULL) { fclose(fp); goto bail; } PyFile_SetBufSize(file_obj, bufsize); #else file_obj = PyFile_FromFd(fd, name, mode, bufsize, NULL, NULL, NULL, 1); if (file_obj == NULL) goto bail; #endif bail: PyMem_Free(name); return file_obj; }
PyObject* encoders_encode_shn(PyObject *dummy, PyObject *args, PyObject *keywds) { static char *kwlist[] = {"filename", "pcmreader", "is_big_endian", "signed_samples", "header_data", "footer_data", "block_size", NULL}; char *filename; FILE *output_file; BitstreamWriter* writer; pcmreader* pcmreader; int is_big_endian = 0; int signed_samples = 0; char* header_data; #ifdef PY_SSIZE_T_CLEAN Py_ssize_t header_size; #else int header_size; #endif char* footer_data = NULL; #ifdef PY_SSIZE_T_CLEAN Py_ssize_t footer_size = 0; #else int footer_size = 0; #endif unsigned block_size = 256; unsigned bytes_written = 0; unsigned i; /*fetch arguments*/ if (!PyArg_ParseTupleAndKeywords(args, keywds, "sO&iis#|s#I", kwlist, &filename, pcmreader_converter, &pcmreader, &is_big_endian, &signed_samples, &header_data, &header_size, &footer_data, &footer_size, &block_size)) return NULL; /*ensure PCMReader is compatible with Shorten*/ if ((pcmreader->bits_per_sample != 8) && (pcmreader->bits_per_sample != 16)) { pcmreader->del(pcmreader); PyErr_SetString(PyExc_ValueError, "unsupported bits per sample"); return NULL; } /*open given filename for writing*/ if ((output_file = fopen(filename, "wb")) == NULL) { PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename); pcmreader->del(pcmreader); return NULL; } else { writer = bw_open(output_file, BS_BIG_ENDIAN); } /*write magic number and version*/ writer->build(writer, "4b 8u", "ajkg", 2); bw_add_callback(writer, byte_counter, &bytes_written); /*write Shorten header*/ write_header(writer, pcmreader->bits_per_sample, is_big_endian, signed_samples, pcmreader->channels, block_size); /*issue initial VERBATIM command with header data*/ write_unsigned(writer, COMMAND_SIZE, FN_VERBATIM); write_unsigned(writer, VERBATIM_SIZE, header_size); for (i = 0; i < header_size; i++) write_unsigned(writer, VERBATIM_BYTE_SIZE, (uint8_t)header_data[i]); /*process PCM frames*/ if (encode_audio(writer, pcmreader, signed_samples, block_size)) goto error; /*if there's footer data, issue a VERBATIM command for it*/ if ((footer_data != NULL) && (footer_size > 0)) { write_unsigned(writer, COMMAND_SIZE, FN_VERBATIM); write_unsigned(writer, VERBATIM_SIZE, footer_size); for (i = 0; i < footer_size; i++) write_unsigned(writer, VERBATIM_BYTE_SIZE, (uint8_t)footer_data[i]); } /*issue QUIT command*/ write_unsigned(writer, COMMAND_SIZE, FN_QUIT); /*pad output (not including header) to a multiple of 4 bytes*/ writer->byte_align(writer); while ((bytes_written % 4) != 0) { writer->write(writer, 8, 0); } /*deallocate temporary buffers and close files*/ pcmreader->del(pcmreader); writer->close(writer); Py_INCREF(Py_None); return Py_None; error: pcmreader->del(pcmreader); writer->close(writer); return NULL; }
static PyObject* bignumpy(PyObject* self, PyObject* args) { const char* filename = NULL; PyObject* dtype = NULL; PyObject* shape = Py_None; int fd; PyArrayObject* z; PyArray_Descr* descr; int nd = 0; npy_intp dims[BIGNUMPY_MAXDIMS]; npy_intp strides[BIGNUMPY_MAXDIMS]; size_t nelm; int i; npy_intp stride; PyObject* obj; struct BignumpyObject* bno; if (!PyArg_ParseTuple(args,"sO|O",&filename,&dtype,&shape)) return NULL; // We actually start with the type. If we can't figure out the size // it is useless to open the file. dtype can be almost anything, so // here, we create an array of zeros to get information about the // type using the actual numpy interface z = /*owned*/ (PyArrayObject*)PyObject_CallFunctionObjArgs(ZEROS,EMPTY,dtype,NULL); if (!z) return NULL; Py_INCREF(descr = PyArray_DESCR(z)); Py_DECREF(z); z = NULL; // OK, we can open the file. If it does not exist, we may have to create it fd = open(filename,O_RDWR|O_CREAT,0666); if (fd < 0) { Py_DECREF(descr); return PyErr_SetFromErrnoWithFilename(PyExc_OSError,filename); } // Figure out the current size of the file. struct stat status; if (fstat(fd,&status) < 0) { Py_DECREF(descr); close(fd); return PyErr_SetFromErrnoWithFilename(PyExc_OSError,filename); } //If the size is zero and we have a shape, // then we'll use ftruncate to change the size. If we have no shape, // assume shape is (size(file)/elsize,) if (shape == Py_None) { strides[nd] = descr->elsize; dims[nd++] = status.st_size/descr->elsize; } else { PyObject* iterator = PyObject_GetIter(shape); if (!iterator) { long v = PyInt_AsLong(shape); if (v == -1 && PyErr_Occurred()) { PyErr_SetString(PyExc_RuntimeError,"invalid shape"); Py_DECREF(descr); close(fd); return NULL; } dims[nd++] = v; } else { PyObject* item; while((item = PyIter_Next(iterator))) { if (nd >= BIGNUMPY_MAXDIMS) { Py_DECREF(iterator); Py_DECREF(item); Py_DECREF(descr); close(fd); PyErr_SetString(PyExc_RuntimeError,"shape has too many dimensions"); return NULL; } long v = PyInt_AsLong(item); if (v == -1 && PyErr_Occurred()) { Py_DECREF(iterator); Py_DECREF(item); Py_DECREF(descr); close(fd); PyErr_SetString(PyExc_RuntimeError,"invalid shape"); return NULL; } strides[nd] = 1; dims[nd++] = v; Py_DECREF(item); } Py_DECREF(iterator); } } // ---------------------------------------------------------------------- // Compute the number of required elements // ---------------------------------------------------------------------- nelm = 0; if (nd > 0) { nelm = 1; for(i=0;i<nd;++i) nelm *= dims[i]; } // ---------------------------------------------------------------------- // The strides include the element size. We compute from back to front // ---------------------------------------------------------------------- stride = descr->elsize; for(i=0;i<nd;++i) { strides[nd-1-i] = stride; stride *= dims[nd-1-i]; } // ---------------------------------------------------------------------- // Grow (but do not shrink) to be the expected size // ---------------------------------------------------------------------- off_t expected = nelm * descr->elsize; if (status.st_size < expected) { if (ftruncate(fd,expected) < 0) { Py_DECREF(descr); close(fd); return PyErr_SetFromErrnoWithFilename(PyExc_OSError,filename); } } // ---------------------------------------------------------------------- // At this point, we can map the values into memory // ---------------------------------------------------------------------- if (!expected) expected = 1; // mmap doesn't like 0 size void* m = mmap(NULL,expected,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0); if (m == MAP_FAILED) { Py_DECREF(descr); close(fd); return PyErr_SetFromErrnoWithFilename(PyExc_OSError,filename); } // ---------------------------------------------------------------------- // Make a C object to hold the map state (pointer and size); // ---------------------------------------------------------------------- obj = PyArray_NewFromDescr( &Bignumpy_Type, descr, /* steals reference */ nd, dims, strides, m, NPY_ARRAY_DEFAULT, NULL); bno = (struct BignumpyObject*)obj; bno->fd = fd; bno->map = m; bno->size = expected; return obj; }
static lad_t * newladobject(PyObject *arg) { lad_t *xp; int fd, afmts, imode; char *basedev = NULL; char *mode = NULL; /* Two ways to call linuxaudiodev.open(): open(device, mode) (for consistency with builtin open()) open(mode) (for backwards compatibility) because the *first* argument is optional, parsing args is a wee bit tricky. */ if (!PyArg_ParseTuple(arg, "s|s:open", &basedev, &mode)) return NULL; if (mode == NULL) { /* only one arg supplied */ mode = basedev; basedev = NULL; } if (strcmp(mode, "r") == 0) imode = O_RDONLY; else if (strcmp(mode, "w") == 0) imode = O_WRONLY; else { PyErr_SetString(LinuxAudioError, "mode should be 'r' or 'w'"); return NULL; } /* Open the correct device. The base device name comes from the * AUDIODEV environment variable first, then /dev/dsp. The * control device tacks "ctl" onto the base device name. * * Note that the only difference between /dev/audio and /dev/dsp * is that the former uses logarithmic mu-law encoding and the * latter uses 8-bit unsigned encoding. */ if (basedev == NULL) { /* called with one arg */ basedev = getenv("AUDIODEV"); if (basedev == NULL) /* $AUDIODEV not set */ basedev = "/dev/dsp"; } if ((fd = open(basedev, imode)) == -1) { PyErr_SetFromErrnoWithFilename(LinuxAudioError, basedev); return NULL; } if (imode == O_WRONLY && ioctl(fd, SNDCTL_DSP_NONBLOCK, NULL) == -1) { PyErr_SetFromErrnoWithFilename(LinuxAudioError, basedev); return NULL; } if (ioctl(fd, SNDCTL_DSP_GETFMTS, &afmts) == -1) { PyErr_SetFromErrnoWithFilename(LinuxAudioError, basedev); return NULL; } /* Create and initialize the object */ if ((xp = PyObject_New(lad_t, &Ladtype)) == NULL) { close(fd); return NULL; } xp->x_fd = fd; xp->x_mode = imode; xp->x_icount = xp->x_ocount = 0; xp->x_afmts = afmts; return xp; }
static PyObject * AMC_save (AMC *self, PyObject *args) { char *filename; GIOChannel *file; int size, frames, i, j, k; PyObject *keys; // get filename if (!PyArg_ParseTuple (args, "s;expected 'string'", &filename)) return NULL; file = g_io_channel_new_file (filename, "w", NULL); if (file == NULL) { // FIXME - we should be using the GError, not errno return PyErr_SetFromErrnoWithFilename (PyExc_IOError, filename); } // write out comment size = PyList_Size (self->comments); for (i = 0; i < size; i++) { PyObject *line; char *cline; line = PyList_GetItem (self->comments, i); cline = PyString_AsString (line); g_io_channel_write_chars (file, cline, strlen (cline), NULL, NULL); g_io_channel_write_chars (file, "\n", 1, NULL, NULL); } // write out format size = PyList_Size (self->format); if (size == 0) g_io_channel_write_chars (file, ":FULLY-SPECIFIED\n:DEGREES\n", strlen (":FULLY-SPECIFIED\n:DEGREES\n"), NULL, NULL); for (i = 0; i < size; i++) { PyObject *line; char *cline; line = PyList_GetItem (self->format, i); cline = PyString_AsString (line); g_io_channel_write_chars (file, cline, strlen (cline), NULL, NULL); g_io_channel_write_chars (file, "\n", 1, NULL, NULL); } // get keys keys = PyDict_Keys (self->bones); size = PyList_Size (keys); if (size == 0) // FIXME - throw error return Py_False; // find # of frames { PyObject *bone = PyDict_GetItem (self->bones, PyList_GetItem (keys, 0)); PyArrayObject *array = (PyArrayObject *) bone; frames = array->dimensions[0]; } for (j = 0; j < frames; j++) { GIOStatus status; char *frame; // Write out the frame number frame = g_strdup_printf ("%d\n", j + 1); g_io_channel_write_chars (file, frame, strlen (frame), NULL, NULL); g_free (frame); for (i = 0; i < size; i++) { PyObject *key; char *bone_name; PyArrayObject *bone; // Write the bone name key = PyList_GetItem (keys, i); bone = (PyArrayObject *) PyDict_GetItem (self->bones, key); bone_name = PyString_AsString (key); g_io_channel_write_chars (file, bone_name, strlen (bone_name), NULL, NULL); // Write out the bone data for (k = 0; k < bone->dimensions[1]; k++) { char *data = g_strdup_printf (" %f", *((float*) (bone->data + (j * bone->strides[0]) + (k * bone->strides[1])))); g_io_channel_write_chars (file, data, strlen (data), NULL, NULL); g_free (data); } g_io_channel_write_chars (file, "\n", 1, NULL, NULL); } } g_io_channel_shutdown (file, TRUE, NULL); g_io_channel_unref (file); Py_RETURN_TRUE; }
static PyObject * posix_error_with_allocated_filename(char* name) { PyObject *rc = PyErr_SetFromErrnoWithFilename(PyExc_OSError, name); PyMem_Free(name); return rc; }
PyObject* encoders_encode_opus(PyObject *dummy, PyObject *args, PyObject *keywds) { char *filename; struct PCMReader *pcmreader = NULL; int quality; int original_sample_rate; static char *kwlist[] = {"filename", "pcmreader", "quality", "original_sample_rate", NULL}; result_t result; if (!PyArg_ParseTupleAndKeywords(args, keywds, "sO&ii", kwlist, &filename, py_obj_to_pcmreader, &pcmreader, &quality, &original_sample_rate)) { if (pcmreader != NULL) pcmreader->del(pcmreader); return NULL; } /*sanity check quality*/ if ((quality < 0) || (quality > 10)) { PyErr_SetString(PyExc_ValueError, "quality must be 0-10"); pcmreader->del(pcmreader); return NULL; } /*sanity check original sample rate*/ if (original_sample_rate <= 0) { PyErr_SetString(PyExc_ValueError, "original_sample_rate must be > 0"); pcmreader->del(pcmreader); return NULL; } /*sanity check PCMReader*/ if (pcmreader->sample_rate != 48000) { PyErr_SetString(PyExc_ValueError, "PCMReader sample_rate must be 48000"); pcmreader->del(pcmreader); return NULL; } else if (pcmreader->bits_per_sample != 16) { PyErr_SetString(PyExc_ValueError, "PCMReader bits_per_sample must be 16"); pcmreader->del(pcmreader); return NULL; } result = encode_opus_file(filename, pcmreader, quality, original_sample_rate); pcmreader->del(pcmreader); switch (result) { case ENCODE_OK: default: Py_INCREF(Py_None); return Py_None; case ERR_IOERROR: PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename); return NULL; case ERR_ENCODER_INIT: PyErr_SetString(PyExc_ValueError, "error initializing encoder"); return NULL; case ERR_PCMREADER: /*pass error through from PCMReader*/ return NULL; case ERR_BLOCK_SIZE: PyErr_SetString(PyExc_ValueError, "FrameList too large, please use BufferedPCMReader"); return NULL; case ERR_ENCODE_ERROR: PyErr_SetString(PyExc_ValueError, "Opus encoding error"); return NULL; } }
//----------------------------------------------------------------------------- // SetExecutableName() // Set the script to execute and calculate the directory in which the // executable is found as well as the exclusive (only for this executable) and // shared zip file names. //----------------------------------------------------------------------------- static int SetExecutableName( const char *fileName) // script to execute { char temp[MAXPATHLEN + 12], *ptr; const char *tempStr = NULL; PyObject *encodedObj; #ifndef MS_WINDOWS char linkData[MAXPATHLEN + 1]; struct stat statData; size_t linkSize, i; PyObject *dirName; #endif // store file name g_FileName = cxString_FromString(fileName); if (!g_FileName) return FatalError("cannot create string for file name"); #ifndef MS_WINDOWS for (i = 0; i < 25; i++) { if (cxString_ToString(g_FileName, &encodedObj, &fileName) < 0) return -1; if (lstat(fileName, &statData) < 0) { PyErr_SetFromErrnoWithFilename(PyExc_OSError, (char*) fileName); return FatalError("unable to stat file"); } if (!S_ISLNK(statData.st_mode)) break; linkSize = readlink(fileName, linkData, sizeof(linkData)); if (linkSize < 0) { PyErr_SetFromErrnoWithFilename(PyExc_OSError, (char*) fileName); return FatalError("unable to stat file"); } Py_DECREF(encodedObj); if (linkData[0] == '/') { Py_DECREF(g_FileName); g_FileName = cxString_FromStringAndSize(linkData, linkSize); } else { if (cxString_ToString(g_FileName, &encodedObj, &fileName) < 0) return -1; if (GetDirName(fileName, &dirName) < 0) { Py_DECREF(encodedObj); return -1; } Py_DECREF(encodedObj); if (cxString_ToString(dirName, &encodedObj, &tempStr) < 0) return -1; if (strlen(tempStr) + linkSize + 1 > MAXPATHLEN) { Py_DECREF(dirName); Py_DECREF(encodedObj); return FatalError("cannot dereference link, path too large"); } strcpy(temp, tempStr); Py_DECREF(encodedObj); strcat(temp, "/"); strncat(temp, linkData, linkSize); Py_DECREF(g_FileName); g_FileName = cxString_FromString(temp); } if (!g_FileName) return FatalError("cannot create string for linked file name"); } #endif // calculate and store directory name if (GetDirName(fileName, &g_DirName) < 0) return -1; // calculate and store exclusive zip file name strcpy(temp, fileName); ptr = temp + strlen(temp) - 1; while (ptr > temp && *ptr != SEP && *ptr != '.') ptr--; if (*ptr == '.') *ptr = '\0'; strcat(temp, ".zip"); g_ExclusiveZipFileName = cxString_FromString(temp); if (!g_ExclusiveZipFileName) return FatalError("cannot create string for exclusive zip file name"); // calculate and store shared zip file name if (cxString_ToString(g_DirName, &encodedObj, &tempStr) < 0) return -1; strcpy(temp, tempStr); Py_DECREF(encodedObj); ptr = temp + strlen(temp); *ptr++ = SEP; strcpy(ptr, "library.zip"); g_SharedZipFileName = cxString_FromString(temp); if (!g_SharedZipFileName) return FatalError("cannot create string for shared zip file name"); return 0; }
/* * Return TCP and UDP connections opened by process. * UNIX sockets are excluded. * * Thanks to: * https://github.com/DavidGriffith/finx/blob/master/ * nxsensor-3.5.0-1/src/sysdeps/solaris.c * ...and: * https://hg.java.net/hg/solaris~on-src/file/tip/usr/src/cmd/ * cmd-inet/usr.bin/netstat/netstat.c */ static PyObject * psutil_net_connections(PyObject *self, PyObject *args) { long pid; int sd = NULL; mib2_tcpConnEntry_t *tp = NULL; mib2_udpEntry_t *ude; #if defined(AF_INET6) mib2_tcp6ConnEntry_t *tp6; mib2_udp6Entry_t *ude6; #endif char buf[512]; int i, flags, getcode, num_ent, state; char lip[200], rip[200]; int lport, rport; int processed_pid; struct strbuf ctlbuf, databuf; struct T_optmgmt_req *tor = (struct T_optmgmt_req *)buf; struct T_optmgmt_ack *toa = (struct T_optmgmt_ack *)buf; struct T_error_ack *tea = (struct T_error_ack *)buf; struct opthdr *mibhdr; PyObject *py_retlist = PyList_New(0); PyObject *py_tuple = NULL; PyObject *py_laddr = NULL; PyObject *py_raddr = NULL; PyObject *af_filter = NULL; PyObject *type_filter = NULL; if (py_retlist == NULL) return NULL; if (! PyArg_ParseTuple(args, "lOO", &pid, &af_filter, &type_filter)) goto error; if (!PySequence_Check(af_filter) || !PySequence_Check(type_filter)) { PyErr_SetString(PyExc_TypeError, "arg 2 or 3 is not a sequence"); goto error; } sd = open("/dev/arp", O_RDWR); if (sd == -1) { PyErr_SetFromErrnoWithFilename(PyExc_OSError, "/dev/arp"); goto error; } /* XXX - These 2 are used in ifconfig.c but they seem unnecessary ret = ioctl(sd, I_PUSH, "tcp"); if (ret == -1) { PyErr_SetFromErrno(PyExc_OSError); goto error; } ret = ioctl(sd, I_PUSH, "udp"); if (ret == -1) { PyErr_SetFromErrno(PyExc_OSError); goto error; } */ // OK, this mess is basically copied and pasted from nxsensor project // which copied and pasted it from netstat source code, mibget() // function. Also see: // http://stackoverflow.com/questions/8723598/ tor->PRIM_type = T_SVR4_OPTMGMT_REQ; tor->OPT_offset = sizeof (struct T_optmgmt_req); tor->OPT_length = sizeof (struct opthdr); tor->MGMT_flags = T_CURRENT; mibhdr = (struct opthdr *)&tor[1]; mibhdr->level = EXPER_IP_AND_ALL_IRES; mibhdr->name = 0; mibhdr->len = 0; ctlbuf.buf = buf; ctlbuf.len = tor->OPT_offset + tor->OPT_length; flags = 0; // request to be sent in non-priority if (putmsg(sd, &ctlbuf, (struct strbuf *)0, flags) == -1) { PyErr_SetFromErrno(PyExc_OSError); goto error; } mibhdr = (struct opthdr *)&toa[1]; ctlbuf.maxlen = sizeof (buf); for (;;) { flags = 0; getcode = getmsg(sd, &ctlbuf, (struct strbuf *)0, &flags); if (getcode != MOREDATA || ctlbuf.len < sizeof (struct T_optmgmt_ack) || toa->PRIM_type != T_OPTMGMT_ACK || toa->MGMT_flags != T_SUCCESS) { break; } if (ctlbuf.len >= sizeof (struct T_error_ack) && tea->PRIM_type == T_ERROR_ACK) { PyErr_SetString(PyExc_RuntimeError, "ERROR_ACK"); goto error; } if (getcode == 0 && ctlbuf.len >= sizeof (struct T_optmgmt_ack) && toa->PRIM_type == T_OPTMGMT_ACK && toa->MGMT_flags == T_SUCCESS) { PyErr_SetString(PyExc_RuntimeError, "ERROR_T_OPTMGMT_ACK"); goto error; } databuf.maxlen = mibhdr->len; databuf.len = 0; databuf.buf = (char *)malloc((int)mibhdr->len); if (!databuf.buf) { PyErr_NoMemory(); goto error; } flags = 0; getcode = getmsg(sd, (struct strbuf *)0, &databuf, &flags); if (getcode < 0) { PyErr_SetFromErrno(PyExc_OSError); goto error; } // TCPv4 if (mibhdr->level == MIB2_TCP && mibhdr->name == MIB2_TCP_13) { tp = (mib2_tcpConnEntry_t *)databuf.buf; num_ent = mibhdr->len / sizeof(mib2_tcpConnEntry_t); for (i = 0; i < num_ent; i++, tp++) { processed_pid = tp->tcpConnCreationProcess; if (pid != -1 && processed_pid != pid) continue; // construct local/remote addresses inet_ntop(AF_INET, &tp->tcpConnLocalAddress, lip, sizeof(lip)); inet_ntop(AF_INET, &tp->tcpConnRemAddress, rip, sizeof(rip)); lport = tp->tcpConnLocalPort; rport = tp->tcpConnRemPort; // contruct python tuple/list py_laddr = Py_BuildValue("(si)", lip, lport); if (!py_laddr) goto error; if (rport != 0) { py_raddr = Py_BuildValue("(si)", rip, rport); } else { py_raddr = Py_BuildValue("()"); } if (!py_raddr) goto error; state = tp->tcpConnEntryInfo.ce_state; // add item py_tuple = Py_BuildValue("(iiiNNiI)", -1, AF_INET, SOCK_STREAM, py_laddr, py_raddr, state, processed_pid); if (!py_tuple) { goto error; } if (PyList_Append(py_retlist, py_tuple)) goto error; Py_DECREF(py_tuple); } } #if defined(AF_INET6) // TCPv6 else if (mibhdr->level == MIB2_TCP6 && mibhdr->name == MIB2_TCP6_CONN) { tp6 = (mib2_tcp6ConnEntry_t *)databuf.buf; num_ent = mibhdr->len / sizeof(mib2_tcp6ConnEntry_t); for (i = 0; i < num_ent; i++, tp6++) { processed_pid = tp6->tcp6ConnCreationProcess; if (pid != -1 && processed_pid != pid) continue; // construct local/remote addresses inet_ntop(AF_INET6, &tp6->tcp6ConnLocalAddress, lip, sizeof(lip)); inet_ntop(AF_INET6, &tp6->tcp6ConnRemAddress, rip, sizeof(rip)); lport = tp6->tcp6ConnLocalPort; rport = tp6->tcp6ConnRemPort; // contruct python tuple/list py_laddr = Py_BuildValue("(si)", lip, lport); if (!py_laddr) goto error; if (rport != 0) { py_raddr = Py_BuildValue("(si)", rip, rport); } else { py_raddr = Py_BuildValue("()"); } if (!py_raddr) goto error; state = tp6->tcp6ConnEntryInfo.ce_state; // add item py_tuple = Py_BuildValue("(iiiNNiI)", -1, AF_INET6, SOCK_STREAM, py_laddr, py_raddr, state, processed_pid); if (!py_tuple) { goto error; } if (PyList_Append(py_retlist, py_tuple)) goto error; Py_DECREF(py_tuple); } } #endif // UDPv4 else if (mibhdr->level == MIB2_UDP || mibhdr->level == MIB2_UDP_ENTRY) { ude = (mib2_udpEntry_t *)databuf.buf; num_ent = mibhdr->len / sizeof(mib2_udpEntry_t); for (i = 0; i < num_ent; i++, ude++) { processed_pid = ude->udpCreationProcess; if (pid != -1 && processed_pid != pid) continue; // XXX Very ugly hack! It seems we get here only the first // time we bump into a UDPv4 socket. PID is a very high // number (clearly impossible) and the address does not // belong to any valid interface. Not sure what else // to do other than skipping. if (processed_pid > 131072) continue; inet_ntop(AF_INET, &ude->udpLocalAddress, lip, sizeof(lip)); lport = ude->udpLocalPort; py_laddr = Py_BuildValue("(si)", lip, lport); if (!py_laddr) goto error; py_raddr = Py_BuildValue("()"); if (!py_raddr) goto error; py_tuple = Py_BuildValue("(iiiNNiI)", -1, AF_INET, SOCK_DGRAM, py_laddr, py_raddr, PSUTIL_CONN_NONE, processed_pid); if (!py_tuple) { goto error; } if (PyList_Append(py_retlist, py_tuple)) goto error; Py_DECREF(py_tuple); } } #if defined(AF_INET6) // UDPv6 else if (mibhdr->level == MIB2_UDP6 || mibhdr->level == MIB2_UDP6_ENTRY) { ude6 = (mib2_udp6Entry_t *)databuf.buf; num_ent = mibhdr->len / sizeof(mib2_udp6Entry_t); for (i = 0; i < num_ent; i++, ude6++) { processed_pid = ude6->udp6CreationProcess; if (pid != -1 && processed_pid != pid) continue; inet_ntop(AF_INET6, &ude6->udp6LocalAddress, lip, sizeof(lip)); lport = ude6->udp6LocalPort; py_laddr = Py_BuildValue("(si)", lip, lport); if (!py_laddr) goto error; py_raddr = Py_BuildValue("()"); if (!py_raddr) goto error; py_tuple = Py_BuildValue("(iiiNNiI)", -1, AF_INET6, SOCK_DGRAM, py_laddr, py_raddr, PSUTIL_CONN_NONE, processed_pid); if (!py_tuple) { goto error; } if (PyList_Append(py_retlist, py_tuple)) goto error; Py_DECREF(py_tuple); } } #endif free(databuf.buf); } close(sd); return py_retlist; error: Py_XDECREF(py_tuple); Py_XDECREF(py_laddr); Py_XDECREF(py_raddr); Py_DECREF(py_retlist); // TODO : free databuf if (sd != NULL) close(sd); return NULL; }
int VorbisDecoder_init(decoders_VorbisDecoder *self, PyObject *args, PyObject *kwds) { char* filename; ogg_status ogg_result; vorbis_status vorbis_result; self->ogg_stream = NULL; self->ogg_file = NULL; self->packet = br_substream_new(BS_LITTLE_ENDIAN); if (!PyArg_ParseTuple(args, "s", &filename)) goto error; self->ogg_file = fopen(filename, "rb"); if (self->ogg_file == NULL) { PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename); goto error; } else { self->ogg_stream = oggreader_open(self->ogg_file); } /*read identification packet*/ if ((ogg_result = oggreader_next_packet(self->ogg_stream, self->packet)) == OGG_OK) { if ((vorbis_result = vorbis_read_identification_packet(self->packet, &(self->identification))) != VORBIS_OK) { PyErr_SetString(vorbis_exception(vorbis_result), vorbis_strerror(vorbis_result)); goto error; } } else { PyErr_SetString(ogg_exception(ogg_result), ogg_strerror(ogg_result)); goto error; } /*skip comments packet, but ensure it's positioned properly*/ if ((ogg_result = oggreader_next_packet(self->ogg_stream, self->packet)) == OGG_OK) { if (vorbis_read_common_header(self->packet) != 3) { PyErr_SetString(PyExc_ValueError, "comment not second Ogg packet"); goto error; } } else { PyErr_SetString(ogg_exception(ogg_result), ogg_strerror(ogg_result)); goto error; } /*read setup header*/ if ((ogg_result = oggreader_next_packet(self->ogg_stream, self->packet)) == OGG_OK) { if ((vorbis_result = vorbis_read_setup_packet(self->packet)) != VORBIS_OK) { PyErr_SetString(vorbis_exception(vorbis_result), vorbis_strerror(vorbis_result)); goto error; } } else { PyErr_SetString(ogg_exception(ogg_result), ogg_strerror(ogg_result)); goto error; } return 0; error: return -1; }