DZone Snippets: linux code

Change Ubuntu's default text editor

jrobertson (James Robertson) — Tue, 02 Sep 2008 15:40:32 GMT

Tired with using nano as the default text editor in Ubuntu? To change the text editor permanently to vi type the following command from the command line.
sudo update-alternatives --config editor

Convert an MP3 to WAV

jrobertson (James Robertson) — Tue, 26 Aug 2008 17:30:42 GMT

Using Ubuntu you will first need to apt-get install mpg123.
mpg123 -w record1.wav Record1.mp3
Reference: using mpg123 to convert .mp3 to .wav files [LinuxQuestions.org]

See also: Convert a WAV to OGG [dzone.com]

Handling conflicting config files after emerging

jrobertson (James Robertson) — Thu, 21 Aug 2008 20:30:32 GMT

When emerging a program on Gentoo it's not uncommon for a configuration conflict to occur when a new config file contains new settings. To summon the program to interactively choose which config files to update type the following:
etc-update

Putting on your Ruby shoes

jrobertson (James Robertson) — Sun, 17 Aug 2008 14:38:27 GMT

Source: Shoes • The Tutorial Walkthrough [shoooes.net] via Shoes - Ruby’s Cross Platform GUI App Toolkit - Grows Up [RubyInside.com]

Installation (Ubuntu):
Prior to installation ensure the following packages are installed:
libcairo2-dev libpixman-1-dev libpango1.0-dev libungif4-dev libjpeg62-dev libgtk2.0-dev vlc libvlc0-dev libsqlite3-dev libcurl4-openssl-dev ruby1.8-dev rake

- 1) Download the source code from http://shoooes.net/downloads/
- 2) tar zxvf shoes*
- 3) cd shoes*
- 4) make
- 5) sudo make install

file: firstapp.rb



Shoes.app {

  @push = button "Push me"

  @note = para "Nothing pushed so far"



  @push.click {

    @note.replace "Aha! Click!"

  }

}

running the code: type shoes firstapp.rb

output: firstapp.rb application [twitxr.com]

Reference: Running with Shoes - A Mini GUI Toolkit [juixe.com]
- Shoes reference manual (from the command line type shoes -m) Shoes Reference Manual screenshot [twitxr.com]

upgrade python 2.4 to 2.5 on debian etch

indiehead (John) — Wed, 13 Aug 2008 09:45:21 GMT

upgrade python 2.4 to 2.5 on debian etch



aptitude install python2.5



# which python

/usr/bin/python



# which python2.5

/usr/bin/python2.5





..create symbolic link from /python to /python2.5 to force debian to default to 2.5

ln -sf /usr/bin/python2.5 /usr/bin/python

Edit WAV files from the command line using SOX

jrobertson (James Robertson) — Sun, 03 Aug 2008 23:17:16 GMT

Source: Using SOX [upenn.edu]

Converting a raw to wav
sox -r 441000 -s -w foo.raw foo.wav
Increase the volume
sox -v 2.0 foo.wav bar.wav
Check the maximum volume before increasing the volume causes clipping
sox foo.wav -e stat -v
Extract a part of the wav file
sox Input.wav Half2.wav trim 30:00 60:00
Synthesizing sound for fun
sox -t nul /dev/null sine.wav synth 1.0 sine 1000.0
types of sound can be sine, square, triangle, sawtooth, trapetz (trapezoidal), exp (exponential), whitenoise, pinknoise, and brownnoise.

Combining wav files
soxmix sine100.wav sine250.wav sine100-250.wav

Convert a WAV to OGG

jrobertson (James Robertson) — Sun, 03 Aug 2008 11:55:24 GMT



oggenc -o asterisk-caller.ogg prompt03.wav

Note: To install oggenc on Ubuntu: apt-get vorbis-tools

Disk/flash benchmark

sandos (John Bäckstrand) — Thu, 24 Jul 2008 16:50:04 GMT

Adapted from a LKML posted program. I think I added write support, this for benchmarking random access writes on flash.



/* Simple multi-threaded I/O benchmark program.

 * Copyright (C) Michael Tokarev, mjt@tls.msk.ru

 * Public domain.

 *

 * To compile:

 *   gcc -o iot iot.c -lpthread

 * To run:

 *   Either with disk device or with pre-existing file.

 *    ./iot [options] filename

 *   Filename is the file or device to test on.

 *   By default it uses 8Kb I/O blocks and does sequential read test

 *   until interrupted.

 *   To indicate when to stop:

 *     -t sec - run for this many seconds, say, 30, to eliminate random

 *       noise.

 *     -i num - perform this many I/O operations

 *   To indicate R/W mode:

 *     -wn, -Wn, -rn, -Rn --

 *       perform linear or random write (note: all data will be lost!),

 *       or linear or random read, using given number of threads (n).

 *   I/O modes:

 *    -s - syncronous write (O_SYNC)

 *    -d - direct I/O (O_DIRECT)

 *    -b bs - block size in bytes

 *   And finally:

 *    -h - display usage.

 * Example:

 *   ./iot -t30 -W4 -R4 -d -b8192 /dev/sdb

 * perform random read/write test (4 readers and 4 writers)

 * for 30 seconds using direct I/O and block size of 8Kb.

 *

 * Note: for small blocksize (<64Kb at least) and using direct random I/O,

 * nowadays drives sometimes gives transfer rates below 1Mb/sec - this is

 * expectable, don't be afraid of so low numbers.  The reason is simple:

 * in order to access a given block of data, a disk drive has to seek to the

 * right track (average seek time) and wait for the right sector to be near

 * the head (rotation latency).  Sum up the two, and divide 1 sec to the

 * result -- you'll have max number of requests/sec a drive can perform,

 * not counting the actual data transfer (which reduces this number further).

 * With, say, 5ms seek time + rotation latency, we'll have 200 requests/sec,

 * which, with 4Kb request size, will be about 800Kb/sec - which is below

 * 1Mb/sec, not counting the actual transfer...

 *

 */



#define _GNU_SOURCE

#define _BSD_SOURCE

#define _LARGEFILE_SOURCE

#define _FILE_OFFSET_BITS 64



//#define USE_DEV_URANDOM       /* was not a good idea */



#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 



#ifndef BLKGETSIZE64

#define BLKGETSIZE64 _IOR(0x12,114,size_t)

 /* linux-specific. return device size in bytes (u64 *arg) */

#endif



static void edie(const char *what) {

  fprintf(stderr, "%s: %m \n", what);

  exit(1);

}



#ifdef USE_DEV_URANDOM

static int randfd;

#endif

static int oflags;              // open flags

static char *fn;                // filename

static unsigned bs = 8192;      // block size

static unsigned bc;             // block count (device size in blocks)

static unsigned bm;             // blocks to do



#define MFrnd   1

#define MFwrt   2

#define LinRd   0

#define RndRd   MFrnd

#define LinWr   MFwrt

#define RndWr   (MFrnd|MFwrt)



struct state {

  int fd;

  char *buf;

  unsigned ioc;         // I/O count

  int (*workfn)(struct state *, unsigned blocknr);

  unsigned (*posfn)(struct state *s);

  unsigned opi;         // operation index

  unsigned i;           // curidx

  double stime;         // start time

  unsigned bn;          // current block number for linear i/o

};

static unsigned int alternate;

static unsigned tioc;   // total i/o count

static struct state *states;

static unsigned nt[4];

static unsigned ntt;

static volatile unsigned running;

static const char *const ion[4] = { "LinRd", "RndRd", "LinWr", "RndWr" };



static pthread_mutex_t rnmtx = PTHREAD_MUTEX_INITIALIZER;

static pthread_cond_t rncond = PTHREAD_COND_INITIALIZER;



static double curtime(void) {

  struct timeval tv;

  gettimeofday(&tv, NULL);

  return tv.tv_sec + tv.tv_usec / 1000000.0;

}



static unsigned randpos(struct state *s) {

  unsigned n;

#ifdef USE_DEV_URANDOM

  read(randfd, &n, sizeof(n));

#else

  n = lrand48();

#endif

  s = s;

  if(alternate == 1) {

    if(n > bc/2) {

      return bc-1;

    } else {

      return 0;

    }

  }

  return n % bc;

}



static unsigned linpos(struct state *s) {

  if (s->bn >= bc)

    s->bn = 0;

  return s->bn++;

}



static int wwriter(struct state *s, unsigned b) {

  return pwrite(s->fd, s->buf, bs, (off_t)b * bs);

}

static int wreader(struct state *s, unsigned b) {

  return pread(s->fd, s->buf, bs, (off_t)b * bs);

}



static void pst(FILE *f) {

  double ct = curtime();

  double r[4] = { 0, 0, 0, 0 };

  unsigned c[4] = { 0, 0, 0, 0 };

  unsigned i;

  double d;

  for(i = 0; i < ntt; ++i) {

    d = ct - states[i].stime;

    r[states[i].opi] += states[i].ioc / d;

    c[states[i].opi] += states[i].ioc;

  }

#if 1

  for(i = 0; i < 4; ++i)

    if (c[i])

      fprintf(f, " %s %u %.2f", ion[i], c[i], r[i] * bs / 1024 / 1024);

#endif

}



static void incc() {

  if (!(++tioc % 1000))

    pthread_cond_signal(&rncond);

}

static void decnr() {

  pthread_mutex_lock(&rnmtx);

  --running;

  pthread_mutex_unlock(&rnmtx);

  pthread_cond_broadcast(&rncond);

}



static volatile int term;



void *worker(void *arg) {

  struct state *s = arg;

  s->workfn = s->opi & MFwrt ? wwriter : wreader;

  s->posfn  = s->opi & MFrnd ? randpos : linpos;

  s->fd = open(fn, (s->opi & MFwrt ? O_WRONLY : O_RDONLY) | oflags);

  if (s->fd < 0) {

    int e = errno;

    decnr();

    errno = e;

    edie(fn);

  }

  s->stime = curtime();

  for(;;) {

    if (term) break;

    if (s->workfn(s, s->posfn(s)) < 0) {

      perror(ion[s->opi]);

      break;

    }

    ++s->ioc;

    incc();

    if (bm && s->ioc >= bm) break;

  }

  decnr();

  return 0;

}



static void sig(int s) {

  term = s;

}



int main(int argc, char **argv) {

  int c;

  unsigned i, j;

  unsigned tm = 0;

  struct state *s;

  char *buf;

  struct timeval  first,

                second,

                lapsed;



  while((c = getopt(argc, argv, "r::R::w::W::adsb:n:i:t:h")) != EOF) switch(c) {

  case 'r': nt[LinRd] = optarg ? atoi(optarg) : 1; break;

  case 'R': nt[RndRd] = optarg ? atoi(optarg) : 1; break;

  case 'w': nt[LinWr] = optarg ? atoi(optarg) : 1; break;

  case 'W': nt[RndWr] = optarg ? atoi(optarg) : 1; break;

  case 'd': oflags |= O_DIRECT; break;

  case 's': oflags |= O_SYNC; break;

  case 'b': bs = atoi(optarg); break;

  case 'n': bc = atoi(optarg); break;

  case 'i': bm = atoi(optarg); break;

  case 't': tm = atoi(optarg); break;

  case 'a': alternate = 1; break;

  case 'h':

    puts(

"iotest: perform I/O speed test\n"

"Usage is: iotest [options] device-or-file\n"

"options:\n"

" -r[n] - linear read test (n readers)\n"

" -R[n] - random read test (n readers)\n"

" -w[n] - linear write test (n writers)\n"

" -W[n] - random write test (n writers)\n"

" -d - use direct I/O (O_DIRECT)\n"

" -s - use syncronous I/O (O_SYNC)\n"

" -b bs - blocksize (default is 8192)\n"

" -n bc - block count (default is whole device/file)\n"

" -i nb - number of I/O iterations to perform\n"

" -t sec - time to spend on all I/O\n"

" -h - this help\n"

"It's ok to specify all, one or some of -r,-R,-w and -W\n"

);

    return 0;

  default: fprintf(stderr, "try `iotest -h' for help\n"); exit(1);

  }



  if (optind + 1 != argc) {

    fprintf(stderr, "exactly one device/file argument expected\n");

    return 1;

  }

  fn = argv[optind];



  ntt = nt[0] + nt[1] + nt[2] + nt[3];

  if (!ntt)

    nt[LinRd] = ntt = 1;



  c = open(fn, (nt[LinWr] + nt[RndWr] ? O_RDWR : O_RDONLY) | oflags);

  if (c < 0) edie(fn);

  if (!bc) {

    unsigned long long sz;

    struct stat st;

    fstat(c, &st);

    if (st.st_size) sz = st.st_size;

    else ioctl(c, BLKGETSIZE64, &sz);

    bc = sz / bs;

    fprintf(stderr, "size = %lld (%u blocks)\n", sz, bc);

  }

  close(c);

  if (nt[RndRd] || nt[RndWr]) {

#ifdef USE_DEV_URANDOM

    randfd = open("/dev/urandom", O_RDONLY);

    if (randfd < 0) edie("/dev/urandom");

#else

#if 0

    struct timeval tv;

    gettimeofday(&tv, NULL);

    srand48(tv.tv_usec ^ getpid());

#else

    srand48(0xfeda432); // arbitrary, to get repeated values on repeated runs

#endif

#endif

  }



  gettimeofday(&first, NULL);



  states = calloc(ntt, sizeof(*states));

  s = states;



  buf = valloc(ntt * bs);

  if (tm) {

    signal(SIGALRM, sig);

    alarm(tm);

  }

  running = ntt;

  for(j = 0; j < 4; ++j)

    for(i = 0; i < nt[j]; ++i) {

      pthread_t t;

      s->buf = buf; buf += bs;

      s->opi = j;

      s->i = i;

      pthread_create(&t, NULL, worker, s++);

    }

  while(running) {

    pthread_cond_wait(&rncond, &rnmtx);

    putc('\r', stderr);

    pst(stderr);

  }



  putc('\r', stderr);

  pst(stdout);

  putc('\n', stdout);



  gettimeofday(&second, NULL);



  if (first.tv_usec > second.tv_usec) {

    second.tv_usec += 1000000;

    second.tv_sec--;

  }



  lapsed.tv_usec = second.tv_usec - first.tv_usec;

  lapsed.tv_sec  = second.tv_sec  - first.tv_sec;







  if (nt[RndRd] || nt[RndWr]) {

        printf("I/O latency: %f\n", (lapsed.tv_sec*1000+(lapsed.tv_usec/1000))/(float)tioc);



  }



  return 0;

}

Listing the files and subdirectories in C - Linux

Tvrtko (Tvrtko) — Tue, 08 Jul 2008 01:13:50 GMT

// program lists the files and subdirectories within a given directory in full path



#include 

#include 

#include 

#include 



char *path_cat (const char *str1, char *str2);



int main () {

	struct dirent *dp;



        // enter existing path to directory below

	const char *dir_path="/path/to/directory/to/list";

	DIR *dir = opendir(dir_path);

	while ((dp=readdir(dir)) != NULL) {

		char *tmp;

		tmp = path_cat(dir_path, dp->d_name);

		printf("%s\n", tmp);

		free(tmp);

		tmp=NULL;

	}

	closedir(dir);

	return 0;

}



char *path_cat (const char *str1, char *str2) {

	size_t str1_len = strlen(str1);

	size_t str2_len = strlen(str2);

	char *result;

	result = malloc((str1_len+str2_len+1)*sizeof *result);

	strcpy (result,str1);

	int i,j;

	for(i=str1_len, j=0; ((i<(str1_len+str2_len)) && (j		result[i]=str2[j];

	}

	result[str1_len+str2_len]='\0';

	return result;

}

Removing Files of Size Zero

k1mmeh (Kim Chirnside) — Mon, 23 Jun 2008 09:00:34 GMT

// description of your code here
This will delete all files in the current directory with size == 0.



find . -type f -size 0k -exec rm {} \; | awk '{ print $8 }'