Exemple #1
0
int _dbx_getBody(FILE *fp, char** x, int ptr) 
{
    int bufsize = 0;
    struct _dbx_block_hdrstruct hdr;
    *x = NULL;
    
    while (ptr != 0) {
	    RET_ERROR(_dbx_getAtPos(fp, ptr, &hdr, sizeof(hdr)), DBX_DATA_READ);
        LE32_CPU(hdr.self);
        LE32_CPU(hdr.nextaddressoffset);
        LE16_CPU(hdr.blocksize);
        LE32_CPU(hdr.nextaddress);
        /* this plus one will not be accumulative cause we don't add it to
         * bufsize but we need it so we can terminate the buffer */
	    *x = realloc(*x, bufsize + hdr.blocksize + 1);
	    RET_ERROR(_dbx_get(fp, (*x)+bufsize, hdr.blocksize), DBX_DATA_READ);
	    bufsize += hdr.blocksize;
	    ptr = hdr.nextaddress;
	}
    
	if (*x) 
        (*x)[bufsize] = '\0'; /* terminate the buffer */

    /* size of data read */
	return bufsize; 
}
Exemple #2
0
static gint64
get_pid_status_item (int pid, const char *item, MonoProcessError *error, int multiplier)
{
#if defined(__APPLE__)
	// ignore the multiplier
	
	gint64 ret;
	task_t task;
	struct task_basic_info t_info;
	mach_msg_type_number_t th_count = TASK_BASIC_INFO_COUNT;
	kern_return_t mach_ret;

	if (pid == getpid ()) {
		/* task_for_pid () doesn't work on ios, even for the current process */
		task = mach_task_self ();
	} else {
		do {
			mach_ret = task_for_pid (mach_task_self (), pid, &task);
		} while (mach_ret == KERN_ABORTED);

		if (mach_ret != KERN_SUCCESS)
			RET_ERROR (MONO_PROCESS_ERROR_NOT_FOUND);
	}

	do {
		mach_ret = task_info (task, TASK_BASIC_INFO, (task_info_t)&t_info, &th_count);
	} while (mach_ret == KERN_ABORTED);

	if (mach_ret != KERN_SUCCESS) {
		if (pid != getpid ())
			mach_port_deallocate (mach_task_self (), task);
		RET_ERROR (MONO_PROCESS_ERROR_OTHER);
	}

	if (strcmp (item, "VmRSS") == 0 || strcmp (item, "VmHWM") == 0 || strcmp (item, "VmData") == 0)
		ret = t_info.resident_size;
	else if (strcmp (item, "VmSize") == 0 || strcmp (item, "VmPeak") == 0)
		ret = t_info.virtual_size;
	else if (strcmp (item, "Threads") == 0)
		ret = th_count;
	else
		ret = 0;

	if (pid != getpid ())
		mach_port_deallocate (mach_task_self (), task);
	
	return ret;
#else
	char buf [64];
	char *s;

	s = get_pid_status_item_buf (pid, item, buf, sizeof (buf), error);
	if (s)
		return ((gint64) atol (s)) * multiplier;
	return 0;
#endif
}
static int
mixer_set_levels (struct sb_mixer_levels *user_l)
{
#define cmix(v) ((((v.r*100+7)/15)<<8)| ((v.l*100+7)/15))

  struct sb_mixer_levels l;

  IOCTL_FROM_USER ((char *) &l, (char *) user_l, 0, sizeof (l));

  if (l.master.l & ~0xF || l.master.r & ~0xF
      || l.line.l & ~0xF || l.line.r & ~0xF
      || l.voc.l & ~0xF || l.voc.r & ~0xF
      || l.fm.l & ~0xF || l.fm.r & ~0xF
      || l.cd.l & ~0xF || l.cd.r & ~0xF
      || l.mic & ~0x7)
    return (RET_ERROR (EINVAL));

  pas_mixer_set (SOUND_MIXER_VOLUME, cmix (l.master));
  pas_mixer_set (SOUND_MIXER_LINE, cmix (l.line));
  pas_mixer_set (SOUND_MIXER_PCM, cmix (l.voc));
  pas_mixer_set (SOUND_MIXER_ALTPCM, cmix (l.voc));
  pas_mixer_set (SOUND_MIXER_SYNTH, cmix (l.fm));
  pas_mixer_set (SOUND_MIXER_CD, cmix (l.cd));
  pas_mixer_set (SOUND_MIXER_MIC, ((l.mic * 100 + 3) / 7) | (((l.mic * 100 + 3) / 7) << 8));
  return (0);
}
Exemple #4
0
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)
{
    int fd, ret, envfd;
    static void * (*func)();
    if (!func) func = (void *(*)()) dlsym(RTLD_NEXT, "accept");
    DEBUG("accept(%d, _, _) called\n", sockfd);

    fd = (int) func(sockfd, addr, addrlen);

    if (_WS_sockfd == 0) {
        _WS_sockfd = fd;

        if (!_WS_rbuf) {
            if (! _WS_init()) {
                RET_ERROR(ENOMEM, "Could not allocate interposer buffer\n");
            }
        }

        ret = _WS_handshake(_WS_sockfd);
        if (ret < 0) {
            errno = EPROTO;
            return ret;
        }
        MSG("interposing on fd %d\n", _WS_sockfd);
    } else {
        DEBUG("already interposing on fd %d\n", _WS_sockfd);
    }

    return fd;
}
Exemple #5
0
int _dbx_getstruct(FILE *fp, int pos, DBXFOLDER* folder) 
{
    struct _dbx_folder_hdrstruct hdr;
    struct _dbx_folderstruct fol;
    
    char *buf, *fname;
    int msgoffset, blockpos=0;
    
    folder->name = NULL;
    
	RET_ERROR(_dbx_getAtPos(fp, pos, &hdr, sizeof(hdr)), DBX_DATA_READ);

    LE32_CPU(hdr.self);
    LE32_CPU(hdr.blocksize);
    LE16_CPU(hdr.unknown2);

	RET_ERROR(_dbx_get(fp, &fol, sizeof(fol)), DBX_DATA_READ);

    LE32_CPU(fol.id);
    LE32_CPU(fol.parent);
    LE32_CPU(fol.unknown6)
    blockpos += sizeof(hdr);
    buf = (char*) malloc(fol.length1);
    msgoffset = hdr.intcount * sizeof(int);
	
    RET_ERROR(_dbx_getAtPos(fp, pos+blockpos+msgoffset, buf, fol.length1), 
               DBX_DATA_READ);
    
    if (strlen(buf) != fol.length1 - 1) { }

    /* Allocate space big enough to hold remainder of block */
    fname = (char*) malloc(hdr.blocksize - blockpos);
    if (!fname) {
        return -1;
	}
	
	RET_ERROR(_dbx_get(fp, fname, hdr.blocksize-blockpos), DBX_DATA_READ);
	
	folder->name = buf;
	folder->fname = fname;
	folder->id = fol.id;
	folder->parentid = fol.parent;
	dbx_errno = DBX_NOERROR;
	return strlen(buf);
}
Exemple #6
0
static int
sb_midi_start_read (int dev)
{
  if (sb_midi_mode != UART_MIDI)
    {
      printk ("SoundBlaster: MIDI input not implemented.\n");
      return RET_ERROR (EPERM);
    }
  return 0;
}
/*
 * This sets aspects of the Mixer that are not volume levels. (Recording
 * source, filter level, I/O filtering, and stereo.)
 */
static int
mixer_set_params (struct sb_mixer_params *user_p)
{
  struct sb_mixer_params p;
  S_BYTE          val;
  int             src;
  unsigned long   flags;

  IOCTL_FROM_USER ((char *) &p, (char *) user_p, 0, sizeof (p));

  if (p.record_source != SRC_MIC
      && p.record_source != SRC_CD
      && p.record_source != SRC_LINE)
    return (RET_ERROR (EINVAL));

  /*
   * I'm not sure if this is The Right Thing.  Should stereo be entirely
   * under control of DSP?  I like being able to toggle it while a sound is
   * playing, so I do this... because I can.
   */

  DISABLE_INTR (flags);

  val = (pas_read (PCM_CONTROL) & ~P_C_MIXER_CROSS_FIELD) | P_C_MIXER_CROSS_R_TO_R | P_C_MIXER_CROSS_L_TO_L;
  if (!p.dsp_stereo)
    val |= (P_C_MIXER_CROSS_R_TO_L | P_C_MIXER_CROSS_L_TO_R);	/* Mono */
  pas_write (val, PCM_CONTROL);

  RESTORE_INTR (flags);

  switch (p.record_source)
    {
    case SRC_CD:
      src = SOUND_MASK_CD;
      break;

    case SRC_LINE:
      src = SOUND_MASK_LINE;
      break;

    default:
      src = SOUND_MASK_MIC;
      break;
    }

  pas_mixer_set (SOUND_MIXER_RECSRC, src);

  /*
   * setmixer (OUT_FILTER, ((dsp_stereo ? STEREO_DAC : MONO_DAC) |
   * (p.filter_output ? FILT_ON : FILT_OFF)));
   */
  return (0);
}
Exemple #8
0
int _dbx_getindex(FILE* fp, int pos, DBX *dbx) 
{
	int x;
	struct _dbx_tableindexstruct tindex;
	struct _dbx_indexstruct index;

	RET_ERROR(_dbx_getAtPos(fp, pos, &tindex, sizeof(tindex)), DBX_INDEX_READ);
	
    LE32_CPU(tindex.self);
    LE32_CPU(tindex.unknown1);
    LE32_CPU(tindex.anotherTablePtr);
    LE32_CPU(tindex.parent);
    LE32_CPU(tindex.indexCount);
    
	if (tindex.indexCount > 0) {
		_dbx_getindex (fp, tindex.anotherTablePtr, dbx);
	}

	pos += sizeof(struct _dbx_tableindexstruct);
	
    for (x = 1; x <= tindex.ptrCount; x++) {
        RET_ERROR(_dbx_getAtPos(fp, pos, &index, 
                  sizeof(struct _dbx_indexstruct)), DBX_INDEX_READ);
        LE32_CPU(index.indexptr);
        LE32_CPU(index.anotherTablePtr);
        LE32_CPU(index.indexCount);

        RET_ERROR(dbx->indexCount < 0, DBX_INDEX_OVERREAD);
		
        dbx->indexes[--dbx->indexCount] = index.indexptr;
        pos += sizeof(struct _dbx_indexstruct);
        if (index.indexCount > 0)
            _dbx_getindex(fp, index.anotherTablePtr, dbx);
    }
	return 0;
}
int
MIDIbuf_open (int dev, struct fileinfo *file)
{
  int             mode, err;

  dev = dev >> 4;
  mode = file->mode & O_ACCMODE;

  if (midibuf_busy)
    return RET_ERROR (EBUSY);

  if (!mpu401_dev)
    {
      printk ("Midi: MPU-401 compatible Midi interface not present\n");
      return RET_ERROR (ENXIO);
    }

  if ((err = midi_devs[mpu401_dev]->open (mpu401_dev, mode, NULL, NULL)) < 0)
    return err;

  midibuf_busy = 1;

  return RET_ERROR (ENXIO);
}
Exemple #10
0
static int
def_tmr_open (int dev, int mode)
{
  if (opened)
    return RET_ERROR (EBUSY);

  tmr_reset ();
  curr_tempo = 60;
  curr_timebase = HZ;
  opened = 1;

  ACTIVATE_TIMER (def_tmr, poll_def_tmr, 1);

  return 0;
}
Exemple #11
0
static int
sb16midi_open (int dev, int mode,
	       void            (*input) (int dev, unsigned char data),
	       void            (*output) (int dev)
)
{
  if (sb16midi_opened)
    {
      return RET_ERROR (EBUSY);
    }

  sb16midi_input_loop ();

  midi_input_intr = input;
  sb16midi_opened = mode;

  return 0;
}
Exemple #12
0
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)
{
    int fd, ret, envfd;
    static void * (*func)();
    if (!func) func = (void *(*)()) dlsym(RTLD_NEXT, "accept");
    DEBUG("accept(%d, _, _) called\n", sockfd);

    fd = (int) func(sockfd, addr, addrlen);

    if (_WS_listen_fd == -1) {
        DEBUG("not interposing\n");
        return fd;
    }

    if (_WS_listen_fd != sockfd) {
        DEBUG("not interposing on fd %d\n", sockfd);
        return fd;
    }


    if (_WS_connections[fd]) {
        MSG("error, already interposing on fd %d\n", fd);
    } else {
        /* It's a port we're interposing on so allocate memory for it */
        if (! (_WS_connections[fd] = malloc(sizeof(_WS_connection)))) {
            RET_ERROR(ENOMEM, "Could not allocate interposer memory\n");
        }
        _WS_connections[fd]->rcarry_cnt = 0;
        _WS_connections[fd]->rcarry[0]  = '\0';
        _WS_connections[fd]->newframe   = 1;

        ret = _WS_handshake(fd);
        if (ret < 0) {
            free(_WS_connections[fd]);
            _WS_connections[fd] = NULL;
            errno = EPROTO;
            return ret;
        }
        MSG("interposing on fd %d (allocated memory)\n", fd);
    }

    return fd;
}
Exemple #13
0
int _dbx_get_from_buf(char* buffer, int pos, void** dest, int type, int max) 
{
    int y;
    /* copy data from buffer to string pointed to by bufx */
    if (type == STRING_TYPE) {
        y = strlen(&buffer[pos]) + 1; /* plus one for string terminator */
        RET_ERROR(y > max, DBX_DATA_READ);
        if (!*dest)
            *dest = (char*) malloc(y);
        strncpy(*dest, &buffer[pos], y);
    } else if (type == INT_TYPE) {  
        memcpy((int*)dest, &buffer[pos], 4);
    } else if (type == W32FT_TYPE) {
        memcpy((struct FILETIME*)dest, &buffer[pos], 8);
    } else if (type == CHAR_TYPE) {
        memcpy((unsigned char*)dest, &buffer[pos], 1);
	}
	
  return 0;
}  
Exemple #14
0
long
attach_sb16midi (long mem_start, struct address_info *hw_config)
{
  int             ok, timeout;
  unsigned long   flags;

  sb16midi_base = hw_config->io_base;

  if (!sb16midi_detected)
    return RET_ERROR (EIO);

  DISABLE_INTR (flags);
  for (timeout = 30000; timeout < 0 && !output_ready (); timeout--);	/*
									 * Wait
									 */
  sb16midi_cmd (UART_MODE_ON);

  ok = 0;
  for (timeout = 50000; timeout > 0 && !ok; timeout--)
    if (input_avail ())
      if (sb16midi_read () == MPU_ACK)
	ok = 1;

  RESTORE_INTR (flags);

  if (num_midis >= MAX_MIDI_DEV)
    {
      printk ("Sound: Too many midi devices detected\n");
      return mem_start;
    }

#if defined(__FreeBSD__)
  printk ("sbmidi0: <SoundBlaster MPU-401>");
#else
  printk (" <SoundBlaster MPU-401>");
#endif

  std_midi_synth.midi_dev = my_dev = num_midis;
  midi_devs[num_midis++] = &sb16midi_operations;
  return mem_start;
}
static int
gus_midi_open (int dev, int mode,
	       void            (*input) (int dev, unsigned char data),
	       void            (*output) (int dev)
)
{

  if (midi_busy)
    {
      printk ("GUS: Midi busy\n");
      return RET_ERROR (EBUSY);
    }

  OUTB (MIDI_RESET, u_MidiControl);
  gus_delay ();

  gus_midi_control = 0;
  input_opened = 0;

  if (mode == OPEN_READ || mode == OPEN_READWRITE)
    {
      gus_midi_control |= MIDI_ENABLE_RCV;
      input_opened = 1;
    }

  if (mode == OPEN_WRITE || mode == OPEN_READWRITE)
    {
      gus_midi_control |= MIDI_ENABLE_XMIT;
    }

  OUTB (gus_midi_control, u_MidiControl);	/*
						 * Enable
						 */

  midi_busy = 1;
  qlen = qhead = qtail = output_used = 0;
  midi_input_intr = input;

  return 0;
}
Exemple #16
0
long
attach_uart6850 (long mem_start, struct address_info *hw_config)
{
  int             ok, timeout;
  unsigned long   flags;

  if (num_midis >= MAX_MIDI_DEV)
    {
      printk ("Sound: Too many midi devices detected\n");
      return mem_start;
    }

  uart6850_base = hw_config->io_base;
  uart6850_irq = hw_config->irq;

  if (!uart6850_detected)
    return RET_ERROR (EIO);

  DISABLE_INTR (flags);

  for (timeout = 30000; timeout < 0 && !output_ready (); timeout--);	/*
									 * Wait
									 */
  uart6850_cmd (UART_MODE_ON);

  ok = 1;

  RESTORE_INTR (flags);

#if defined(__FreeBSD__)
  printk ("uart0: <6850 Midi Interface>");
#else
  printk (" <6850 Midi Interface>");
#endif

  std_midi_synth.midi_dev = my_dev = num_midis;
  midi_devs[num_midis++] = &uart6850_operations;
  return mem_start;
}
Exemple #17
0
static int
uart6850_open (int dev, int mode,
	       void            (*input) (int dev, unsigned char data),
	       void            (*output) (int dev)
)
{
  if (uart6850_opened)
    {
      printk ("Midi6850: Midi busy\n");
      return RET_ERROR (EBUSY);
    }

  uart6850_cmd (UART_RESET);

  uart6850_input_loop ();

  midi_input_intr = input;
  uart6850_opened = mode;
  poll_uart6850 (0);		/*
				 * Enable input polling
				 */

  return 0;
}
Exemple #18
0
ssize_t _WS_send(int sendf, int sockfd, const void *buf,
                 size_t len, int flags)
{
    int rawlen, enclen, rlen, over, left, clen, retlen, dbufsize;
    int sockflags;
    char * target;
    int i;
    static void * (*sfunc)(), * (*sfunc2)();
    if (!sfunc) sfunc = (void *(*)()) dlsym(RTLD_NEXT, "send");
    if (!sfunc2) sfunc2 = (void *(*)()) dlsym(RTLD_NEXT, "write");

    if ((_WS_sockfd == 0) || (_WS_sockfd != sockfd)) {
        // Not our file descriptor, just pass through
        if (sendf) {
            return (ssize_t) sfunc(sockfd, buf, len, flags);
        } else {
            return (ssize_t) sfunc2(sockfd, buf, len);
        }
    }
    DEBUG("_WS_send(%d, _, %d) called\n", sockfd, len);

    sockflags = fcntl(sockfd, F_GETFL, 0);

    dbufsize = (_WS_bufsize * 3)/4 - 2;
    if (len > dbufsize) {
        RET_ERROR(ENOMEM, "send of %d bytes is larger than send buffer\n", len);
    }

    // base64 encode and add frame markers
    rawlen = 0;
    _WS_sbuf[rawlen++] = '\x00';
    enclen = b64_ntop(buf, len, _WS_sbuf+rawlen, _WS_bufsize-rawlen);
    if (enclen < 0) {
        RET_ERROR(EPROTO, "Base64 encoding error\n");
    }
    rawlen += enclen;
    _WS_sbuf[rawlen++] = '\xff';

    rlen = (int) sfunc(sockfd, _WS_sbuf, rawlen, flags);

    if (rlen <= 0) {
        return rlen;
    } else if (rlen < rawlen) {
        // Spin until we can send a whole base64 chunck and frame end
        over = (rlen - 1) % 4;  
        left = (4 - over) % 4 + 1; // left to send
        DEBUG("_WS_send: rlen: %d (over: %d, left: %d), rawlen: %d\n", rlen, over, left, rawlen);
        rlen += left;
        _WS_sbuf[rlen-1] = '\xff';
        i = 0;
        do {
            i++;
            clen = (int) sfunc(sockfd, _WS_sbuf + rlen - left, left, flags);
            if (clen > 0) {
                left -= clen;
            } else if (clen == 0) {
                MSG("_WS_send: got clen %d\n", clen);
            } else if (!(sockflags & O_NONBLOCK)) {
                MSG("_WS_send: clen %d\n", clen);
                return clen;
            }
            if (i > 1000000) { 
                MSG("Could not send final part of frame\n");
            }
        } while (left > 0);
        DEBUG("_WS_send: spins until finished %d\n", i);
    }


    /*
     * Report back the number of original characters sent,
     * not the raw number sent
     */
    // Adjust for framing
    retlen = rlen - 2;
    // Adjust for base64 padding
    if (_WS_sbuf[rlen-1] == '=') { retlen --; }
    if (_WS_sbuf[rlen-2] == '=') { retlen --; }

    // Adjust for base64 encoding
    retlen = (retlen*3)/4;

    /*
    DEBUG("*** send ");
    for (i = 0; i < retlen; i++) {
        DEBUG("%u,", (unsigned char) ((char *)buf)[i]);
    }
    DEBUG(" as '%s' (%d)\n", _WS_sbuf+1, rlen);
    */
    return (ssize_t) retlen;
}
static int
pas_mixer_set (int whichDev, unsigned int level)
{
  int             left, right, devmask, changed, i, mixer = 0;

  TRACE (printk ("static int pas_mixer_set(int whichDev = %d, unsigned int level = %X)\n", whichDev, level));

  left = level & 0x7f;
  right = (level & 0x7f00) >> 8;

  if (whichDev < SOUND_MIXER_NRDEVICES)
    if ((1 << whichDev) & rec_devices)
      mixer = P_M_MV508_INPUTMIX;
    else
      mixer = P_M_MV508_OUTPUTMIX;

  switch (whichDev)
    {
    case SOUND_MIXER_VOLUME:	/* Master volume (0-63) */
      levels[whichDev] = mixer_output (right, left, 63, P_M_MV508_MASTER_A, 0);
      break;

      /*
       * Note! Bass and Treble are mono devices. Will use just the left
       * channel.
       */
    case SOUND_MIXER_BASS:	/* Bass (0-12) */
      levels[whichDev] = mixer_output (right, left, 12, P_M_MV508_BASS, 0);
      break;
    case SOUND_MIXER_TREBLE:	/* Treble (0-12) */
      levels[whichDev] = mixer_output (right, left, 12, P_M_MV508_TREBLE, 0);
      break;

    case SOUND_MIXER_SYNTH:	/* Internal synthesizer (0-31) */
      levels[whichDev] = mixer_output (right, left, 31, P_M_MV508_MIXER | P_M_MV508_FM, mixer);
      break;
    case SOUND_MIXER_PCM:	/* PAS PCM (0-31) */
      levels[whichDev] = mixer_output (right, left, 31, P_M_MV508_MIXER | P_M_MV508_PCM, mixer);
      break;
    case SOUND_MIXER_ALTPCM:	/* SB PCM (0-31) */
      levels[whichDev] = mixer_output (right, left, 31, P_M_MV508_MIXER | P_M_MV508_SB, mixer);
      break;
    case SOUND_MIXER_SPEAKER:	/* PC speaker (0-31) */
      levels[whichDev] = mixer_output (right, left, 31, P_M_MV508_MIXER | P_M_MV508_SPEAKER, mixer);
      break;
    case SOUND_MIXER_LINE:	/* External line (0-31) */
      levels[whichDev] = mixer_output (right, left, 31, P_M_MV508_MIXER | P_M_MV508_LINE, mixer);
      break;
    case SOUND_MIXER_CD:	/* CD (0-31) */
      levels[whichDev] = mixer_output (right, left, 31, P_M_MV508_MIXER | P_M_MV508_CDROM, mixer);
      break;
    case SOUND_MIXER_MIC:	/* External microphone (0-31) */
      levels[whichDev] = mixer_output (right, left, 31, P_M_MV508_MIXER | P_M_MV508_MIC, mixer);
      break;
    case SOUND_MIXER_IMIX:	/* Recording monitor (0-31) (Only available
				 * on the Output Mixer) */
      levels[whichDev] = mixer_output (right, left, 31, P_M_MV508_MIXER | P_M_MV508_IMIXER,
				       P_M_MV508_OUTPUTMIX);
      break;
    case SOUND_MIXER_RECLEV:	/* Recording level (0-15) */
      levels[whichDev] = mixer_output (right, left, 15, P_M_MV508_MASTER_B, 0);
      break;

    case SOUND_MIXER_MUTE:
      return 0;
      break;

    case SOUND_MIXER_ENHANCE:
      i = 0;
      level &= 0x7f;
      if (level)
	i = (level / 20) - 1;

      mode_control &= ~P_M_MV508_ENHANCE_BITS;
      mode_control |= P_M_MV508_ENHANCE_BITS;
      set_mode (mode_control);

      if (i)
	i = (i + 1) * 20;
      return i;
      break;

    case SOUND_MIXER_LOUD:
      mode_control &= ~P_M_MV508_LOUDNESS;
      if (level)
	mode_control |= P_M_MV508_LOUDNESS;
      set_mode (mode_control);
      return !!level;		/* 0 or 1 */
      break;

    case SOUND_MIXER_RECSRC:
      devmask = level & POSSIBLE_RECORDING_DEVICES;

      changed = devmask ^ rec_devices;
      rec_devices = devmask;

      for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
	if (changed & (1 << i))
	  {
	    pas_mixer_set (i, levels[i]);
	  }
      return rec_devices;
      break;

    default:
      return RET_ERROR (EINVAL);
    }

  return (levels[whichDev]);
}
Exemple #20
0
static gint64
get_process_stat_item (int pid, int pos, int sum, MonoProcessError *error)
{
#if defined(__APPLE__) 
	double process_user_time = 0, process_system_time = 0;//, process_percent = 0;
	task_t task;
	struct task_basic_info t_info;
	mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT, th_count;
	thread_array_t th_array;
	size_t i;

	if (task_for_pid(mach_task_self(), pid, &task) != KERN_SUCCESS)
		RET_ERROR (MONO_PROCESS_ERROR_NOT_FOUND);

	if (task_info(task, TASK_BASIC_INFO, (task_info_t)&t_info, &t_info_count) != KERN_SUCCESS) {
		mach_port_deallocate (mach_task_self (), task);
		RET_ERROR (MONO_PROCESS_ERROR_OTHER);
	}
	
	if (task_threads(task, &th_array, &th_count) != KERN_SUCCESS) {
		mach_port_deallocate (mach_task_self (), task);
		RET_ERROR (MONO_PROCESS_ERROR_OTHER);
	}
		
	for (i = 0; i < th_count; i++) {
		double thread_user_time, thread_system_time;//, thread_percent;
		
		struct thread_basic_info th_info;
		mach_msg_type_number_t th_info_count = THREAD_BASIC_INFO_COUNT;
		if (thread_info(th_array[i], THREAD_BASIC_INFO, (thread_info_t)&th_info, &th_info_count) == KERN_SUCCESS) {
			thread_user_time = th_info.user_time.seconds + th_info.user_time.microseconds / 1e6;
			thread_system_time = th_info.system_time.seconds + th_info.system_time.microseconds / 1e6;
			//thread_percent = (double)th_info.cpu_usage / TH_USAGE_SCALE;
			
			process_user_time += thread_user_time;
			process_system_time += thread_system_time;
			//process_percent += th_percent;
		}
	}
	
	for (i = 0; i < th_count; i++)
		mach_port_deallocate(task, th_array[i]);

	mach_port_deallocate (mach_task_self (), task);

	process_user_time += t_info.user_time.seconds + t_info.user_time.microseconds / 1e6;
	process_system_time += t_info.system_time.seconds + t_info.system_time.microseconds / 1e6;
    
	if (pos == 10 && sum == TRUE)
		return (gint64)((process_user_time + process_system_time) * 10000000);
	else if (pos == 10)
		return (gint64)(process_user_time * 10000000);
	else if (pos == 11)
		return (gint64)(process_system_time * 10000000);
		
	return 0;
#else
	char buf [512];
	char *s, *end;
	FILE *f;
	int len, i;
	gint64 value;

	g_snprintf (buf, sizeof (buf), "/proc/%d/stat", pid);
	f = fopen (buf, "r");
	if (!f)
		RET_ERROR (MONO_PROCESS_ERROR_NOT_FOUND);
	len = fread (buf, 1, sizeof (buf), f);
	fclose (f);
	if (len <= 0)
		RET_ERROR (MONO_PROCESS_ERROR_OTHER);
	s = strchr (buf, ')');
	if (!s)
		RET_ERROR (MONO_PROCESS_ERROR_OTHER);
	s++;
	while (g_ascii_isspace (*s)) s++;
	if (!*s)
		RET_ERROR (MONO_PROCESS_ERROR_OTHER);
	/* skip the status char */
	while (*s && !g_ascii_isspace (*s)) s++;
	if (!*s)
		RET_ERROR (MONO_PROCESS_ERROR_OTHER);
	for (i = 0; i < pos; ++i) {
		while (g_ascii_isspace (*s)) s++;
		if (!*s)
			RET_ERROR (MONO_PROCESS_ERROR_OTHER);
		while (*s && !g_ascii_isspace (*s)) s++;
		if (!*s)
			RET_ERROR (MONO_PROCESS_ERROR_OTHER);
	}
	/* we are finally at the needed item */
	value = strtoul (s, &end, 0);
	/* add also the following value */
	if (sum) {
		while (g_ascii_isspace (*s)) s++;
		if (!*s)
			RET_ERROR (MONO_PROCESS_ERROR_OTHER);
		value += strtoul (s, &end, 0);
	}
	if (error)
		*error = MONO_PROCESS_ERROR_NONE;
	return value;
#endif
}
Exemple #21
0
static int
sb_midi_open (int dev, int mode,
	      void            (*input) (int dev, unsigned char data),
	      void            (*output) (int dev)
)
{
  int             ret;

  if (!sb_dsp_ok)
    {
      printk ("SB Error: MIDI hardware not installed\n");
      return RET_ERROR (ENXIO);
    }

  if (sb_midi_busy)
    return RET_ERROR (EBUSY);

  if (mode != OPEN_WRITE && !sb_duplex_midi)
    {
      if (num_midis == 1)
	printk ("SoundBlaster: Midi input not currently supported\n");
      return RET_ERROR (EPERM);
    }

  sb_midi_mode = NORMAL_MIDI;
  if (mode != OPEN_WRITE)
    {
      if (sb_dsp_busy || sb_intr_active)
	return RET_ERROR (EBUSY);
      sb_midi_mode = UART_MIDI;
    }

  if (sb_dsp_highspeed)
    {
      printk ("SB Error: Midi output not possible during stereo or high speed audio\n");
      return RET_ERROR (EBUSY);
    }

  if (sb_midi_mode == UART_MIDI)
    {
      sb_irq_mode = IMODE_MIDI;

      sb_reset_dsp ();

      if (!sb_dsp_command (0x35))
	return RET_ERROR (EIO);	/*
				 * Enter the UART mode
				 */
      sb_intr_active = 1;

      if ((ret = sb_get_irq ()) < 0)
	{
	  sb_reset_dsp ();
	  return 0;		/*
				 * IRQ not free
				 */
	}
      input_opened = 1;
      midi_input_intr = input;
    }

  sb_midi_busy = 1;

  return 0;
}
Exemple #22
0
static int
sb_midi_ioctl (int dev, unsigned cmd, unsigned arg)
{
  return RET_ERROR (EPERM);
}
Exemple #23
0
static int
uart6850_ioctl (int dev, unsigned cmd, unsigned arg)
{
  return RET_ERROR (EINVAL);
}
Exemple #24
0
ssize_t _WS_recv(int recvf, int sockfd, const void *buf,
                 size_t len, int flags)
{
    int rawcount, deccount, left, rawlen, retlen, decodelen;
    int sockflags;
    int i;
    char * fstart, * fend, * cstart;

    static void * (*rfunc)(), * (*rfunc2)();
    if (!rfunc) rfunc = (void *(*)()) dlsym(RTLD_NEXT, "recv");
    if (!rfunc2) rfunc2 = (void *(*)()) dlsym(RTLD_NEXT, "read");

    if (len == 0) {
        return 0;
    }

    if ((_WS_sockfd == 0) || (_WS_sockfd != sockfd)) {
        // Not our file descriptor, just pass through
        if (recvf) {
            return (ssize_t) rfunc(sockfd, buf, len, flags);
        } else {
            return (ssize_t) rfunc2(sockfd, buf, len);
        }
    }
    DEBUG("_WS_recv(%d, _, %d) called\n", sockfd, len);

    sockflags = fcntl(sockfd, F_GETFL, 0);
    left = len;
    retlen = 0;

    // first copy in any carry-over bytes
    if (_WS_rcarry_cnt) {
        if (_WS_rcarry_cnt == 1) {
            DEBUG("Using carry byte: %u (", _WS_rcarry[0]);
        } else if (_WS_rcarry_cnt == 2) {
            DEBUG("Using carry bytes: %u,%u (", _WS_rcarry[0],
                    _WS_rcarry[1]);
        } else {
            RET_ERROR(EIO, "Too many carry-over bytes\n");
        }
        if (len <= _WS_rcarry_cnt) {
            DEBUG("final)\n");
            memcpy((char *) buf, _WS_rcarry, len);
            _WS_rcarry_cnt -= len;
            return len;
        } else {
            DEBUG("prepending)\n");
            memcpy((char *) buf, _WS_rcarry, _WS_rcarry_cnt);
            retlen += _WS_rcarry_cnt;
            left -= _WS_rcarry_cnt;
            _WS_rcarry_cnt = 0;
        }
    }

    // Determine the number of base64 encoded bytes needed
    rawcount = (left * 4) / 3 + 3;
    rawcount -= rawcount%4;

    if (rawcount > _WS_bufsize - 1) {
        RET_ERROR(ENOMEM, "recv of %d bytes is larger than buffer\n", rawcount);
    }

    i = 0;
    while (1) {
        // Peek at everything available
        rawlen = (int) rfunc(sockfd, _WS_rbuf, _WS_bufsize-1,
                            flags | MSG_PEEK);
        if (rawlen <= 0) {
            DEBUG("_WS_recv: returning because rawlen %d\n", rawlen);
            return (ssize_t) rawlen;
        }
        fstart = _WS_rbuf;

        /*
        while (rawlen >= 2 && fstart[0] == '\x00' && fstart[1] == '\xff') {
            fstart += 2;
            rawlen -= 2;
        }
        */
        if (rawlen >= 2 && fstart[0] == '\x00' && fstart[1] == '\xff') {
            rawlen = (int) rfunc(sockfd, _WS_rbuf, 2, flags);
            if (rawlen != 2) {
                RET_ERROR(EIO, "Could not strip empty frame headers\n");
            }
            continue;
        }

        fstart[rawlen] = '\x00';

        if (rawlen - _WS_newframe >= 4) {
            // We have enough to base64 decode at least 1 byte
            break;
        }
        // Not enough to base64 decode
        if (sockflags & O_NONBLOCK) {
            // Just tell the caller to call again
            DEBUG("_WS_recv: returning because O_NONBLOCK, rawlen %d\n", rawlen);
            errno = EAGAIN;
            return -1;
        }
        // Repeat until at least 1 byte (4 raw bytes) to decode
        i++;
        if (i > 1000000) { 
            MSG("Could not send final part of frame\n");
        }
    }

    /*
    DEBUG("_WS_recv, left: %d, len: %d, rawlen: %d, newframe: %d, raw: ",
          left, len, rawlen, _WS_newframe);
    for (i = 0; i < rawlen; i++) {
        DEBUG("%u,", (unsigned char) ((char *) fstart)[i]);
    }
    DEBUG("\n");
    */

    if (_WS_newframe) {
        if (fstart[0] != '\x00') {
            RET_ERROR(EPROTO, "Missing frame start\n");
        }
        fstart++;
        rawlen--;
        _WS_newframe = 0;
    }

    fend = memchr(fstart, '\xff', rawlen);

    if (fend) {
        _WS_newframe = 1;
        if ((fend - fstart) % 4) {
            RET_ERROR(EPROTO, "Frame length is not multiple of 4\n");
        }
    } else {
        fend = fstart + rawlen - (rawlen % 4);
        if (fend - fstart < 4) {
            RET_ERROR(EPROTO, "Frame too short\n");
        }
    }

    // How much should we consume
    if (rawcount < fend - fstart) {
        _WS_newframe = 0;
        deccount = rawcount;
    } else {
        deccount = fend - fstart;
    }

    // Now consume what we processed
    if (flags & MSG_PEEK) {
        MSG("*** Got MSG_PEEK ***\n");
    } else {
        rfunc(sockfd, _WS_rbuf, fstart - _WS_rbuf + deccount + _WS_newframe, flags);
    }

    fstart[deccount] = '\x00'; // base64 terminator

    // Do direct base64 decode, instead of decode()
    decodelen = b64_pton(fstart, (char *) buf + retlen, deccount);
    if (decodelen <= 0) {
        RET_ERROR(EPROTO, "Base64 decode error\n");
    }

    if (decodelen <= left) {
        retlen += decodelen;
    } else {
        retlen += left;

        if (! (flags & MSG_PEEK)) {
            // Add anything left over to the carry-over
            _WS_rcarry_cnt = decodelen - left;
            if (_WS_rcarry_cnt > 2) {
                RET_ERROR(EPROTO, "Got too much base64 data\n");
            }
            memcpy(_WS_rcarry, buf + retlen, _WS_rcarry_cnt);
            if (_WS_rcarry_cnt == 1) {
                DEBUG("Saving carry byte: %u\n", _WS_rcarry[0]);
            } else if (_WS_rcarry_cnt == 2) {
                DEBUG("Saving carry bytes: %u,%u\n", _WS_rcarry[0],
                        _WS_rcarry[1]);
            } else {
                MSG("Waah2!\n");
            }
        }
    }
    ((char *) buf)[retlen] = '\x00';

    /*
    DEBUG("*** recv %s as ", fstart);
    for (i = 0; i < retlen; i++) {
        DEBUG("%u,", (unsigned char) ((char *) buf)[i]);
    }
    DEBUG(" (%d -> %d): %d\n", deccount, decodelen, retlen);
    */
    return retlen;
}
Exemple #25
0
static int
def_tmr_ioctl (int dev,
	       unsigned int cmd, unsigned int arg)
{
  switch (cmd)
    {
    case SNDCTL_TMR_SOURCE:
      return IOCTL_OUT (arg, TMR_INTERNAL);
      break;

    case SNDCTL_TMR_START:
      tmr_reset ();
      tmr_running = 1;
      return 0;
      break;

    case SNDCTL_TMR_STOP:
      tmr_running = 0;
      return 0;
      break;

    case SNDCTL_TMR_CONTINUE:
      tmr_running = 1;
      return 0;
      break;

    case SNDCTL_TMR_TIMEBASE:
      {
	int             val = IOCTL_IN (arg);

	if (val)
	  {
	    if (val < 1)
	      val = 1;
	    if (val > 1000)
	      val = 1000;
	    curr_timebase = val;
	  }

	return IOCTL_OUT (arg, curr_timebase);
      }
      break;

    case SNDCTL_TMR_TEMPO:
      {
	int             val = IOCTL_IN (arg);

	if (val)
	  {
	    if (val < 8)
	      val = 8;
	    if (val > 250)
	      val = 250;
	    tmr_offs = tmr_ctr;
	    ticks_offs += tmr2ticks (tmr_ctr);
	    tmr_ctr = 0;
	    curr_tempo = val;
	  }

	return IOCTL_OUT (arg, curr_tempo);
      }
      break;

    case SNDCTL_SEQ_CTRLRATE:
      if (IOCTL_IN (arg) != 0)	/* Can't change */
	return RET_ERROR (EINVAL);

      return IOCTL_OUT (arg, ((curr_tempo * curr_timebase) + 30) / 60);
      break;

    case SNDCTL_TMR_METRONOME:
      /* NOP */
      break;

    default:;
    }

  return RET_ERROR (EINVAL);
}
Exemple #26
0
int _dbx_getitem (FILE *fp, int pos, void **item, int type, int flags) {
	int x;
	char *bufptr, *buffer; 
	void **bufx;
	int readtype=STRING_TYPE;
	
	DBXEMAIL *email = NULL;
	DBXFOLDER *folder = NULL;

	struct _dbx_email_headerstruct blockhdr;
	struct _dbx_email_pointerstruct blockp;

	int body = (flags&DBX_FLAG_BODY?1:0);
	
	if (type == DBX_TYPE_EMAIL) {
	  email = (DBXEMAIL*) malloc(sizeof(DBXEMAIL));
	  memset (email, 0, sizeof(DBXEMAIL));
	  email->type = DBX_TYPE_EMAIL;
	  *item = email;
	  email->email = NULL;
	} else {
	  folder = (DBXFOLDER*) malloc(sizeof(DBXFOLDER));
	  memset (folder, 0, sizeof(DBXFOLDER));
	  folder->type = DBX_TYPE_FOLDER;
	  *item = folder;
	}

	RET_ERROR(_dbx_getAtPos(fp, pos, &blockhdr, sizeof(blockhdr)), 
              DBX_INDEX_READ);
   
    LE32_CPU(blockhdr.self);
    LE32_CPU(blockhdr.size);
    LE32_CPU(blockhdr.u1);
    
	/* we will load all the block into memory 
     * as we will be accessing it byte by byte */

	buffer = (char*) malloc(blockhdr.size);
	RET_ERROR(_dbx_get(fp, buffer, blockhdr.size), DBX_DATA_READ);
	bufptr = buffer;
	if (email)
		email->data_offset = -1;

	for (x = 0; x < blockhdr.count; x++) {
	  blockp.val = 0;

	  memcpy(&(blockp.type), bufptr, 1);    /* this will copy the type */
	  memcpy(&(blockp.val), bufptr+1, 3);   /* and the 3 byte int */
      
      /* we pretend it's a four byte integer */
      LE32_CPU(blockp.val); 
      
	  if (type == DBX_TYPE_EMAIL) {
	    switch (blockp.type) {
	    case 0x01: 
            /* pointer to flag */
	    	email->flag = 0;
	    	bufx = (void**)&(email->flag);
	    	readtype = CHAR_TYPE;
	    	break;
	    case 0x04: 
            /*pointer to dataptr */
	        bufx = (void**)&(email->data_offset);
	        readtype = INT_TYPE;
	        break;
	    case 0x05: 
            /* asciiz string of subject (without RE: or FWD: etc...) */
	        bufx = (void**)&(email->psubject);
	        readtype = STRING_TYPE;
	        break;
	    case 0x07: 
            /* message id of email */
	        bufx = (void**)&(email->messageid);
	        readtype = STRING_TYPE;
	        break;
	    case 0x08: 
            /* second copy of subject. Original text (with RE: etc...) */
            bufx = (void**)&(email->subject);
	        readtype = STRING_TYPE;
	        break;
	    case 0x0A: 
            /* msg-id of parent(s) */
	        bufx = (void**)&(email->parent_message_ids);
	        readtype = STRING_TYPE;
	        break;
	    case 0x0C: 
            /* name of server used to fetch email */
	    	bufx = (void**)&(email->fetched_server);
	    	readtype = STRING_TYPE;
	    	break;
	    case 0x0D: 
            /* Sender's name */
	        bufx = (void**)&(email->sender_name);
	        readtype = STRING_TYPE;
	        break;
	    case 0x0E: 
            /* Sender's email address */
	        bufx = (void**)&(email->sender_address);
	        readtype = STRING_TYPE;
	        break;
	    case 0x12: 
            /* date - of what i'm not sure. 
             * It is in a win32 FILETIME structure. 
             * needs converting to something */
			bufx = (void**)&(email->date);
			readtype = W32FT_TYPE;
			break;
	    case 0x13: 
            /* recipient's name */
	        bufx = (void**)&(email->recip_name);
	        readtype = STRING_TYPE;
	        break;
	    case 0x14: 
            /* recipient's email address */
	        bufx = (void**)&(email->recip_address);
	        readtype = STRING_TYPE;
	        break;
	    case 0x1A: 
            /* Name of Account used to fetch email */
	    	bufx = (void**)&(email->oe_account_name);
	    	readtype = STRING_TYPE;
	    	break;
	    case 0x1B: 
            /* String version of account number 
             * used to fetch email (eg "00000001") */
	    	bufx = (void**)&(email->oe_account_num);
	    	readtype = STRING_TYPE;
	    	break;
	    case 0x80: 
            /* email's ID */
	        bufx = NULL;
	        email->id = blockp.val;
	        break;
	    case 0x81: 
            /* email's flag */
	    	bufx=NULL;
	    	email->flag = blockp.val;
	    	break;
	    case 0x84: 
            /* direct offset of first email data block */
	        email->data_offset = blockp.val;
	        bufx = NULL;
	        break;
	    /*	    
        case 0x02: //currently unknown
	    case 0x06: //currently unknown
	    case 0x09:
	    case 0x0B:
	    case 0x0C:
	    case 0x11: //currently unknown
	    case 0x1A:
	    case 0x1B:
	    case 0x1C: //currently unknown
	    case 0x81: //currently unknown
	    case 0x90: //currently unknown
	    case 0x91: //currently unknown
	        bufx = NULL;
	        break; */
	    default:
	      bufx = NULL;
	    }
	  } else {
	    switch(blockp.type) {
	    case 0x02: 
            /* descriptive name */
	        bufx = (void**)&(folder->name);
	        readtype = STRING_TYPE;
	        break;
	    case 0x03: 
            /* filename */
	        bufx = (void**)&(folder->fname);
	        readtype = STRING_TYPE;
	        break;
	    case 0x80: 
            /* current id */
	        bufx = NULL;
	        folder->id = blockp.val;
	        break;
	    case 0x81: 
            /* parent id */
	        bufx = NULL;
	        folder->parentid = blockp.val;
	        break;
	    /*	    
        case 0x86: //unknown
	    case 0x87: //unknown
	    case 0x88: //unknown
	    case 0x8A: //unknown
	    case 0x8B: //unknown
	        bufx = NULL;
	        break;*/
	    default:
	      bufx = NULL;
	    }
	  }

	  if (bufx)
	        if (_dbx_get_from_buf(buffer, blockp.val + (blockhdr.count*4), 
                                      bufx, readtype, blockhdr.size))
	            return 1; /* an error occured */
	  bufptr += 4; /* size of data */
	}
	free (buffer);
    
	/* if we are doing folder types, we have now finished */
	if (type == DBX_TYPE_FOLDER || body == 0)
	    return 0;

    RET_ERROR(email->data_offset == -1, DBX_DATA_READ);

	return _dbx_getBody(fp, &(email->email), email->data_offset);
}
Exemple #27
0
static int
sb16midi_ioctl (int dev, unsigned cmd, unsigned arg)
{
  return RET_ERROR (EINVAL);
}