/**
* * @brief Program entry point
* * @param argc The argument counter
* * @param argv The argument vector
* * @return EXIT_SUCCESS on success, EXIT_ERROR in case of an error
* */
int main(int argc, char** argv)
{
/* Define a subroutine where the program jumps to if it exits gracefully */
(void) atexit (cleanup);
/* Input / Output Character Count */
int in_ccount, out_ccount;
/* Save the name of the program */
pgm_name = argv[0];
/* Program is called with arguments */
if (argc > 1)
{
for (int i = 1; i < argc; i++)
{
char* out_name = malloc(sizeof(char)* (strlen(argv[i])+5)); //Allocate memory for the name of the output string
(void) open_stream (argv[i], out_name);
(void) compress (&in_ccount, &out_ccount);
(void) output_summary (argv[i], out_name, in_ccount, out_ccount);
free(out_name);
}
}
else
{
char* out_name = malloc(sizeof(char)* (strlen("stdin.txt")+5)); //Allocate memory for the name of the output string
(void) open_stream ("stdin", out_name );
(void) compress (&in_ccount, &out_ccount);
(void) output_summary ("stdin", out_name, in_ccount, out_ccount);
free(out_name);
}
exit (EXIT_SUCCESS);
}
bool CFFMPEGLoader::CreateMovie(const char *filename, const AVOutputFormat *format, const AVCodecContext *VideoCon, const AVCodecContext *AudioCon) {
if(!filename)
return false;
AVOutputFormat *fmt;
//*fmt=*format;
fmt = guess_format(NULL, filename, NULL);
pFormatCon = av_alloc_format_context();
if(!pFormatCon) {
cout<<"Error while allocating format context\n";
return false;
}
bOutput=true;
strcpy(pFormatCon->filename,filename);
pFormatCon->oformat=fmt;
pAudioStream=pVideoStream=NULL;
if (fmt->video_codec != CODEC_ID_NONE) {
pVideoStream = add_video_stream(pFormatCon, fmt->video_codec,VideoCon);
}
if (fmt->audio_codec != CODEC_ID_NONE) {
pAudioStream = add_audio_stream(pFormatCon, fmt->audio_codec,AudioCon);
}
if (av_set_parameters(pFormatCon, NULL) < 0) {
cout<<"Invalid output format parameters\n";
return false;
}
if (pVideoStream)
open_stream(pFormatCon, pVideoStream);
if (pAudioStream)
open_stream(pFormatCon, pAudioStream);
dump_format(pFormatCon, 0, filename, 1);
if (!(fmt->flags & AVFMT_NOFILE)) {
if (url_fopen(&pFormatCon->pb, filename, URL_WRONLY) < 0) {
cout<<"Could not open '%s'"<<filename<<endl;
return false;
}
}
/* write the stream header, if any */
av_write_header(pFormatCon);
return true;
}
static void main_init(void) {
TRACE(TRACE_DEBUG, "%s", "Starting initialization\n");
/* Initalize the event library */
event_init();
/* Initalize our ô so accurate periodic timer */
if (fms_periodic_init(main_periodic)) {
TRACE(TRACE_ERROR, "%s", "failed to start periodic generator\n");
return;
}
signal(SIGKILL, on_kill);
signal(SIGINT, on_kill);
signal(SIGILL, on_kill);
signal(SIGHUP, on_kill);
signal(SIGQUIT, on_kill);
signal(SIGTERM, on_kill);
signal(SIGSEGV, on_kill);
if(!open_stream()) {
fprintf(stderr, "Could not open stream, sorry\n");
exit(1);
}
TRACE(TRACE_DEBUG, "%s", "Initialization completed\n");
}
/* plain file access, no http! */
int attribute_align_arg mpg123_open(mpg123_handle *mh, const char *path)
{
if(mh == NULL) return MPG123_ERR;
mpg123_close(mh);
return open_stream(mh, path, -1);
}
/* {{{ mysqlnd_net::connect_ex */
static enum_func_status
MYSQLND_METHOD(mysqlnd_net, connect_ex)(MYSQLND_NET * const net, const char * const scheme, const size_t scheme_len,
const zend_bool persistent,
MYSQLND_STATS * const conn_stats, MYSQLND_ERROR_INFO * const error_info)
{
enum_func_status ret = FAIL;
func_mysqlnd_net__open_stream open_stream = NULL;
DBG_ENTER("mysqlnd_net::connect_ex");
net->packet_no = net->compressed_envelope_packet_no = 0;
net->data->m.close_stream(net, conn_stats, error_info);
open_stream = net->data->m.get_open_stream(net, scheme, scheme_len, error_info);
if (open_stream) {
php_stream * net_stream = open_stream(net, scheme, scheme_len, persistent, conn_stats, error_info);
if (net_stream) {
(void) net->data->m.set_stream(net, net_stream);
net->data->m.post_connect_set_opt(net, scheme, scheme_len, conn_stats, error_info);
ret = PASS;
}
}
DBG_RETURN(ret);
}
int attribute_align_arg mpg123_open_fd(mpg123_handle *mh, int fd)
{
if(mh == NULL) return MPG123_ERR;
mpg123_close(mh);
return open_stream(mh, NULL, fd);
}
/*
* Open both player and recorder.
*/
PJ_DEF(pj_status_t) pjmedia_snd_open(int rec_id,
int play_id,
unsigned clock_rate,
unsigned channel_count,
unsigned samples_per_frame,
unsigned bits_per_sample,
pjmedia_snd_rec_cb rec_cb,
pjmedia_snd_play_cb play_cb,
void *user_data,
pjmedia_snd_stream **p_snd_strm)
{
PJ_ASSERT_RETURN(rec_cb && play_cb && p_snd_strm, PJ_EINVAL);
return open_stream( PJMEDIA_DIR_CAPTURE_PLAYBACK,
rec_id,
play_id,
clock_rate,
channel_count,
samples_per_frame,
bits_per_sample,
rec_cb,
play_cb,
user_data,
p_snd_strm);
}
static void
print_trace(void)
{
void *array[MAX_BACKTRACE];
size_t size;
char **strings;
size_t i;
if (backtrace_mode == 0)
return;
if (!mb_stream) {
init_env();
mb_stream = open_stream();
}
size = backtrace(array, backtrace_mode);
strings = backtrace_symbols(array, size);
fprintf(mb_stream, "# Obtained %zd stack frames.\n", size);
for (i = 0; i < size; i++)
fprintf(mb_stream, "# [BT] %d: %s\n", i, strings[i]);
free (strings);
}
int main(int argc, char *argv[]) {
if (argc < 3) {
fprintf(stderr, "usage: backend-test <input-file> <output-file>\n");
return 1;
}
FILE *src = fopen(argv[1], "r");
if (src == NULL) {
fprintf(stderr, "backend-test: no such file or directory\n");
return 1;
}
stream *in = open_stream(src);
block_statement *block = parse(in);
close_stream(in);
fclose(src);
analyze(block);
code_system *system = generate(block);
optimize(system);
FILE *out = fopen(argv[2], "w");
if (out == NULL) {
fprintf(stderr, "backend-test: error opening output-file\n");
return 1;
}
backend_write(system, out);
fflush(out);
fclose(out);
exit(0);
}
static void asx_parse_entryref(ASX_Parser_t* parser,char* buffer,char** _attribs) {
char *href;
stream_t* stream;
int f=DEMUXER_TYPE_UNKNOWN;
if(parser->deep > 0)
return;
href = asx_get_attrib("HREF",_attribs);
if(href == NULL) {
asx_warning_attrib_required(parser,"ENTRYREF" ,"HREF" );
return;
}
stream=open_stream(href,0,&f);
if(!stream) {
mp_msg(MSGT_PLAYTREE,MSGL_WARN,"Can't open playlist %s\n",href);
free(href);
return;
}
mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Not recursively loading playlist %s\n",href);
free_stream(stream);
free(href);
//mp_msg(MSGT_PLAYTREE,MSGL_INFO,"Need to implement entryref\n");
}
static int net_stream_open(client_t* cl,char* url) {
int file_format=DEMUXER_TYPE_UNKNOWN;
mp_net_stream_opened_t ret;
if(cl->stream) {
if(!write_error(cl->fd,"A stream is currently opened\n"))
return 0;
return 1;
}
mp_msg(MSGT_NETST,MSGL_V,"Open stream %s\n",url);
cl->stream = open_stream(url,NULL,&file_format);
if(!cl->stream) {
if(!write_error(cl->fd,"Open failed\n"))
return 0;
return 1;
}
stream_reset(cl->stream);
stream_seek(cl->stream,cl->stream->start_pos);
ret.file_format = file_format;
ret.flags = cl->stream->flags;
ret.sector_size = cl->stream->sector_size;
ret.start_pos = cl->stream->start_pos;
ret.end_pos = cl->stream->end_pos;
net_stream_opened_2_me(&ret);
if(!write_packet(cl->fd,NET_STREAM_OK,(char*)&ret,sizeof(mp_net_stream_opened_t)))
return 0;
return 1;
}
static int start_file(char *name)
{
char buf[MAXFILENAME+20];
int fd;
if (play_f!=-1)
{
replay_abort();
close(play_f);
play_f=-1;
CancelWaitableTimer(timer);
replay_pause();
set_buttons(0);
}
fd=open_stream(-1, name, SM_READ, 0);
if (fd==-1)
return 0;
play_f=fd;
play_format=ttyrec_r_find_format(0, name, "baudrate");
play_filename=name;
replay_start();
snprintf(buf, sizeof(buf), "Termplay: %s (%s)", filename, play_format);
SetWindowText(wndMain, buf);
set_toolbar_state(1);
play_state=2;
do_replay();
return 1;
}
ASS_Track *mp_ass_read_stream(ASS_Library *library, const char *fname,
char *charset)
{
ASS_Track *track;
struct stream *s = open_stream(fname, NULL, NULL);
if (!s)
// Stream code should have printed an error already
return NULL;
struct bstr content = stream_read_complete(s, NULL, 100000000, 1);
if (content.start == NULL)
mp_tmsg(MSGT_ASS, MSGL_ERR, "Refusing to load subtitle file "
"larger than 100 MB: %s\n", fname);
free_stream(s);
if (content.len == 0) {
talloc_free(content.start);
return NULL;
}
content.start[content.len] = 0;
track = ass_read_memory(library, content.start, content.len, charset);
if (track) {
free(track->name);
track->name = strdup(fname);
}
talloc_free(content.start);
return track;
}
void print_group(Group *group, int expand, struct Redir *rd)
{
if (group && open_stream(rd, group->my_corpus->corpus->charset)) {
switch (GlobalPrintMode) {
case PrintSGML:
sgml_print_group(group, expand, rd->stream);
break;
case PrintHTML:
html_print_group(group, expand, rd->stream);
break;
case PrintLATEX:
latex_print_group(group, expand, rd->stream);
break;
case PrintASCII:
ascii_print_group(group, expand, rd->stream);
break;
default:
cqpmessage(Error, "Unknown print mode");
break;
}
close_stream(rd);
}
}
void
mb_log(const char *fmt, ...)
{
va_list ap;
struct timeval tv;
if (!mb_stream) {
init_env();
mb_stream = open_stream();
}
va_start(ap, fmt);
if (gettimeofday(&tv, NULL) < 0)
fprintf(stderr, "gettimeofday(2) failed: %s", strerror(errno));
else {
fprintf(mb_stream,
#if 0
"%10lu:%06u.%06u:%10zu:",
++seq,
#else
"%06u.%06u:%10zu:",
#endif /* 0 */
(unsigned)tv.tv_sec, (unsigned)tv.tv_usec, mb_allocated);
}
vfprintf(mb_stream, fmt, ap);
fputc('\n', mb_stream);
fflush(mb_stream);
va_end(ap);
}
/**
* Prints the contents of a ContextDescriptor either to stdout or a pager
* (NB this uses its own internal stream).
*/
void
PrintContextDescriptor(ContextDescriptor *cdp)
{
FILE *fd;
struct Redir rd = { NULL, NULL, NULL, 0, 0 }; /* for paging (with open_stream()) */
int stream_ok;
if (cdp) {
stream_ok = open_stream(&rd, ascii);
fd = (stream_ok) ? rd.stream : NULL; /* use pager, or simply print to stdout if it fails */
if (pretty_print) {
fprintf(fd, "===Context Descriptor=======================================\n");
fprintf(fd, "\n");
fprintf(fd, "left context: %d ", cdp->left_width);
switch (cdp->left_type) {
case CHAR_CONTEXT:
fprintf(fd, "characters\n"); break;
case WORD_CONTEXT:
fprintf(fd, "tokens\n"); break;
case STRUC_CONTEXT:
case ALIGN_CONTEXT:
fprintf(fd, "%s\n",
cdp->left_structure_name ? cdp->left_structure_name : "???");
}
fprintf(fd, "right context: %d ", cdp->right_width);
switch (cdp->right_type) {
case CHAR_CONTEXT:
fprintf(fd, "characters\n"); break;
case WORD_CONTEXT:
fprintf(fd, "tokens\n"); break;
case STRUC_CONTEXT:
case ALIGN_CONTEXT:
fprintf(fd, "%s\n",
cdp->right_structure_name ? cdp->right_structure_name : "???");
}
fprintf(fd, "corpus position: %s\n", cdp->print_cpos ? "shown" : "not shown");
fprintf(fd, "target anchors: %s\n", show_targets ? "shown" : "not shown");
fprintf(fd, "\n");
PrintAttributes(fd, "Positional Attributes:", cdp->attributes, 0);
fprintf(fd, "\n");
PrintAttributes(fd, "Structural Attributes:", cdp->strucAttributes, 1);
fprintf(fd, "\n");
/* PrintAttributes(fd, "Structure Values: ", cdp->printStructureTags); */
/* fprintf(fd, "\n"); */
PrintAttributes(fd, "Aligned Corpora: ", cdp->alignedCorpora, 0);
fprintf(fd, "\n");
fprintf(fd, "============================================================\n");
}
else {
PrintAttributesSimple(fd, "p-Att", cdp->attributes, 0);
PrintAttributesSimple(fd, "s-Att", cdp->strucAttributes, 1);
PrintAttributesSimple(fd, "a-Att", cdp->alignedCorpora, 0);
}
if (stream_ok)
close_stream(&rd); /* close pipe to pager if we were using it */
}
}
void
Email::sendExit( ClassAd* ad, int exit_reason )
{
open_stream( ad, exit_reason );
writeExit( ad, exit_reason );
writeCustom( ad );
send();
}
// This method sucks. As soon as we have a real solution for storing
// all 4 of these values in the job classad, it should be removed.
void
Email::sendExitWithBytes( ClassAd* ad, int exit_reason,
float run_sent, float run_recv,
float tot_sent, float tot_recv )
{
open_stream( ad, exit_reason );
writeExit( ad, exit_reason );
writeBytes( run_sent, run_recv, tot_sent, tot_recv );
writeCustom( ad );
send();
}
static void coco_print_byte(struct MC6809 *cpu) {
int byte;
/* Open stream for output if it's not already */
if (!stream_dest) return;
if (!stream) open_stream();
/* Print byte */
byte = MC6809_REG_A(cpu);
if (stream) {
fputc(byte, stream);
}
}
int i2c_open(const char *path, int *error) {
int i2c_fd;
int errsv = 0;
if((i2c_fd = open_stream(path, &errsv)) < 0) {
perror("error: i2c_open() failure");
if(errsv == EACCES) {
*error = E_ACCESS_DENIED;
}
return -1;
}
return i2c_fd;
}
PJ_DEF(pj_status_t) pjmedia_snd_open_player( int index,
unsigned clock_rate,
unsigned channel_count,
unsigned samples_per_frame,
unsigned bits_per_sample,
pjmedia_snd_play_cb play_cb,
void *user_data,
pjmedia_snd_stream **p_snd_strm )
{
return open_stream(PJMEDIA_DIR_PLAYBACK, PJMEDIA_AUD_INVALID_DEV, index,
clock_rate, channel_count, samples_per_frame,
bits_per_sample, NULL, play_cb,
user_data, p_snd_strm);
}
PJ_DEF(pj_status_t) pjmedia_snd_open_rec( int index,
unsigned clock_rate,
unsigned channel_count,
unsigned samples_per_frame,
unsigned bits_per_sample,
pjmedia_snd_rec_cb rec_cb,
void *user_data,
pjmedia_snd_stream **p_snd_strm)
{
return open_stream(PJMEDIA_DIR_CAPTURE, index, PJMEDIA_AUD_INVALID_DEV,
clock_rate, channel_count, samples_per_frame,
bits_per_sample, rec_cb, NULL,
user_data, p_snd_strm);
}
ASS_Track *mp_ass_read_stream(ASS_Library *library, const char *fname,
char *charset)
{
int i;
char *buf = NULL;
ASS_Track *track;
size_t sz = 0;
size_t buf_alloc = 0;
stream_t *fd;
fd = open_stream(fname, NULL, NULL);
if (!fd)
// Stream code should have printed an error already
return NULL;
if (fd->end_pos > STREAM_BUFFER_SIZE)
/* read entire file if size is known */
buf_alloc = fd->end_pos;
else
buf_alloc = 1000;
for (;;) {
if (sz > 100000000) {
mp_tmsg(MSGT_ASS, MSGL_ERR, "Refusing to load subtitle file "
"larger than 100 MB: %s\n", fname);
sz = 0;
break;
}
buf_alloc = FFMAX(buf_alloc, sz + (sz >> 1));
buf_alloc = FFMIN(buf_alloc, 100000001);
buf = realloc(buf, buf_alloc + 1);
i = stream_read(fd, buf + sz, buf_alloc - sz);
if (i <= 0)
break;
sz += i;
}
free_stream(fd);
if (!sz) {
free(buf);
return NULL;
}
buf[sz] = 0;
buf = realloc(buf, sz + 1);
track = ass_read_memory(library, buf, sz, charset);
if (track) {
free(track->name);
track->name = strdup(fname);
}
free(buf);
return track;
}
PJ_DEF(pj_status_t) pjmedia_snd_open_player( int index,
unsigned clock_rate,
unsigned channel_count,
unsigned samples_per_frame,
unsigned bits_per_sample,
pjmedia_snd_play_cb play_cb,
void *user_data,
pjmedia_snd_stream **p_snd_strm)
{
PJ_ASSERT_RETURN(play_cb && p_snd_strm, PJ_EINVAL);
return open_stream( PJMEDIA_DIR_PLAYBACK, -1, index,
clock_rate, channel_count, samples_per_frame,
bits_per_sample, NULL, play_cb, user_data,
p_snd_strm);
}
/*
* Open stream.
*/
PJ_DEF(pj_status_t) pjmedia_snd_open_rec( int index,
unsigned clock_rate,
unsigned channel_count,
unsigned samples_per_frame,
unsigned bits_per_sample,
pjmedia_snd_rec_cb rec_cb,
void *user_data,
pjmedia_snd_stream **p_snd_strm)
{
PJ_ASSERT_RETURN(rec_cb && p_snd_strm, PJ_EINVAL);
return open_stream( PJMEDIA_DIR_CAPTURE, index, -1,
clock_rate, channel_count, samples_per_frame,
bits_per_sample, rec_cb, NULL, user_data,
p_snd_strm);
}
/* Called when the PIA bus containing STROBE is changed */
void printer_strobe(_Bool strobe, int data) {
/* Ignore if this is not a transition to high */
if (strobe == strobe_state) return;
strobe_state = strobe;
if (!strobe_state) return;
/* Open stream for output if it's not already */
if (!stream_dest) return;
if (!stream) open_stream();
/* Print byte */
if (stream) {
fputc(data, stream);
}
/* ACK, and schedule !ACK */
DELEGATE_SAFE_CALL1(printer_signal_ack, 1);
ack_clear_event.at_tick = event_current_tick + (OSCILLATOR_RATE / 150000);
event_queue(&MACHINE_EVENT_LIST, &ack_clear_event);
}
ASS_Track* ass_read_stream(ASS_Library* library, const char *fname, char *charset) {
char *buf = NULL;
ASS_Track *track;
size_t sz = 0;
size_t buf_alloc = 0;
stream_t *fd;
fd = open_stream(fname, NULL, NULL);
if (!fd) {
mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FopenFailed, fname);
return NULL;
}
if (fd->end_pos > STREAM_BUFFER_SIZE)
/* read entire file if size is known */
buf_alloc = fd->end_pos;
for (;;) {
int i;
if (buf_alloc >= 100*1024*1024) {
mp_msg(MSGT_ASS, MSGL_INFO, MSGTR_LIBASS_RefusingToLoadSubtitlesLargerThan100M, fname);
sz = 0;
break;
}
if (buf_alloc < sz + STREAM_BUFFER_SIZE)
buf_alloc += STREAM_BUFFER_SIZE;
buf = realloc(buf, buf_alloc + 1);
i = stream_read(fd, buf + sz, buf_alloc - sz);
if (i <= 0) break;
sz += i;
}
free_stream(fd);
if (!sz) {
free(buf);
return NULL;
}
buf[sz] = 0;
buf = realloc(buf, sz + 1);
track = ass_read_memory(library, buf, sz, charset);
if (track) {
free(track->name);
track->name = strdup(fname);
}
free(buf);
return track;
}
static void main_init(void) {
uint8_t byte_idx;
TRACE(TRACE_DEBUG, "%s", "Starting initialization\n");
/* Initalize our SPI link to IO processor */
if (spi_link_init()) {
TRACE(TRACE_ERROR, "%s", "failed to open SPI link \n");
return;
}
spistream_init(&on_spistream_msg_received,
&on_spistream_msg_sent);
for(byte_idx=1; byte_idx < 123; byte_idx++) {
spistream_msg[byte_idx] = byte_idx;
}
/* Initalize the event library */
event_init();
/* Initalize our ô so accurate periodic timer */
if (fms_periodic_init(main_periodic)) {
TRACE(TRACE_ERROR, "%s", "failed to start periodic generator\n");
return;
}
signal(SIGKILL, on_kill);
signal(SIGINT, on_kill);
signal(SIGILL, on_kill);
signal(SIGHUP, on_kill);
signal(SIGQUIT, on_kill);
signal(SIGTERM, on_kill);
signal(SIGSEGV, on_kill);
signal(SIGPIPE, on_dead_pipe);
if(!open_stream()) {
fprintf(LOG_OUT, "Could not open stream, sorry\n");
exit(1);
}
TRACE(TRACE_DEBUG, "%s", "Initialization completed\n");
}
static void export_file(void)
{
char fn[MAXFILENAME],errmsg[MAXFILENAME+20+128];
OPENFILENAME dlg;
int record_f;
const char *format;
struct timeval sel1, sel2;
memset(&dlg, 0, sizeof(dlg));
dlg.lStructSize=sizeof(dlg);
dlg.hwndOwner=wndMain;
dlg.lpstrFilter=
"ttyrec videos (*.ttyrec, *.ttyrec.[gz|bz2|xz])\000*.ttyrec;*.ttyrec.gz;*.ttyrec.bz2;*.ttyrec.xz\000"
"nh-recorder videos (*.nh, *.nh.[gz|bz2|xz])\000*.nh;*.nh.gz;*.nh.bz2;*.nh.xz\000"
"RealLogs videos (*.rl, *.rl.[gz|bz2|xz])\000*.rl;*.rl.gz;*.rl.bz2;*.rl.xz\000"
"ANSI logs (*.txt, *.txt.[gz|bz2|xz])\000*.txt;*.txt.gz;*.txt.bz2;*.txt.xz\000"
"all files\000*\000"
"\000\000";
dlg.nFilterIndex=1;
dlg.lpstrFile=fn;
dlg.nMaxFile=MAXFILENAME;
dlg.Flags=OFN_HIDEREADONLY|OFN_LONGNAMES;
dlg.lpstrDefExt="ttyrec.bz2";
*fn=0;
if (!GetSaveFileName(&dlg))
return;
format=ttyrec_w_find_format(0, fn, "ansi");
if ((record_f=open(fn, O_WRONLY|O_CREAT|O_TRUNC, 0666))==-1)
{
sprintf(errmsg, "Can't write to %s: %s", fn, strerror(errno));
MessageBox(wndMain, errmsg, "Write error", MB_ICONERROR);
return;
}
record_f=open_stream(record_f, fn, SM_WRITE, 0);
sel1=selstart;
tadd(sel1, tdate);
sel2=selend;
tadd(sel2, tdate);
ttyrec_save(ttr, record_f, format, filename, &sel1, &sel2);
}
void
Email::sendAction( ClassAd* ad, const char* reason,
const char* action )
{
if( ! ad ) {
EXCEPT( "Email::sendAction() called with NULL ad!" );
}
if( ! open_stream(ad, -1, action) ) {
// nothing to do
return;
}
writeJobId( ad );
fprintf( fp, "\nis being %s.\n\n", action );
fprintf( fp, "%s", reason );
send();
}