Example #1
0
/*
 *  a write to a closed pipe causes a note to be sent to
 *  the process.
 */
static int32_t
pipewrite(Chan *c, void *va, int32_t n, int64_t mm)
{
	Proc *up = externup();
	Pipe *p;

	if(0)if(!islo())
		print("pipewrite hi %#p\n", getcallerpc()); // devmnt?

	if(waserror()) {
		/* avoid notes when pipe is a mounted queue */
		if((c->flag & CMSG) == 0)
			postnote(up, 1, "sys: write on closed pipe", NUser);
		nexterror();
	}

	p = c->aux;

	switch(PIPETYPE(c->qid.path)){
	case Qdata0:
		n = qwrite(p->q[1], va, n);
		break;

	case Qdata1:
		n = qwrite(p->q[0], va, n);
		break;

	default:
		panic("pipewrite");
	}

	poperror();
	return n;
}
Example #2
0
/*
 *  a write to a closed pipe causes a note to be sent to
 *  the process.
 */
static long
pipewrite(Chan *c, void *va, long n, vlong)
{
	Pipe *p;

	if(!islo())
		print("pipewrite hi %#p\n", getcallerpc(&c));
	if(waserror()) {
		/* avoid notes when pipe is a mounted queue */
		if((c->flag & CMSG) == 0)
			postnote(up, 1, "sys: write on closed pipe", NUser);
		nexterror();
	}

	p = c->aux;

	switch(NETTYPE(c->qid.path)){
	case Qdata0:
		n = qwrite(p->q[1], va, n);
		break;

	case Qdata1:
		n = qwrite(p->q[0], va, n);
		break;

	default:
		panic("pipewrite");
	}

	poperror();
	return n;
}
Example #3
0
/*
 *  A write to a closed pipe causes an EPIPE error to be thrown.
 */
static long pipewrite(struct chan *c, void *va, long n, int64_t ignored)
{
	Pipe *p;
	//Prog *r;

	p = c->aux;

	switch (NETTYPE(c->qid.path)) {
		case Qdata0:
			if (c->flag & O_NONBLOCK)
				n = qwrite_nonblock(p->q[1], va, n);
			else
				n = qwrite(p->q[1], va, n);
			break;

		case Qdata1:
			if (c->flag & O_NONBLOCK)
				n = qwrite_nonblock(p->q[0], va, n);
			else
				n = qwrite(p->q[0], va, n);
			break;

		default:
			panic("pipewrite");
	}

	return n;
}
Example #4
0
/*
 *   Print a string on the console.  Convert \n to \r\n for serial
 *   line consoles.  Locking of the queues is left up to the screen
 *   or uart code.  Multi-line messages to serial consoles may get
 *   interspersed with other messages.
 */
static void
putstrn0(char *str, int n, int usewrite)
{

	if(!islo())
		usewrite = 0;

	/*
	 *  how many different output devices do we need?
	 */
	kmesgputs(str, n);

	/*
	 *  if someone is reading /dev/kprint,
	 *  put the message there.
	 *  if not and there's an attached bit mapped display,
	 *  put the message there.
	 *
	 *  if there's a serial line being used as a console,
	 *  put the message there.
	 */
	if(kprintoq != nil && !qisclosed(kprintoq)){
		if(usewrite)
			qwrite(kprintoq, str, n);
		else
			qiwrite(kprintoq, str, n);
	}else if(screenputs != nil)
		screenputs(str, n);

	uartputs(str, n);
#if 0 // Plan 9 VX
	if(serialoq == nil){
		uartputs(str, n);
		return;
	}

	while(n > 0) {
		t = memchr(str, '\n', n);
		if(t && !kbd.raw) {
			m = t-str;
			if(usewrite){
				qwrite(serialoq, str, m);
				qwrite(serialoq, "\r\n", 2);
			} else {
				qiwrite(serialoq, str, m);
				qiwrite(serialoq, "\r\n", 2);
			}
			n -= m+1;
			str = t+1;
		} else {
			if(usewrite)
				qwrite(serialoq, str, n);
			else
				qiwrite(serialoq, str, n);
			break;
		}
	}
#endif
}
void idaapi dump_type_info(int file_id, const VTBL_info_t& vtbl_info, const qstring& type_name, const std::map<ea_t, VTBL_info_t>& vtbl_map) {
	struc_t * struc_type = get_struc(get_struc_id(type_name.c_str()));
	if (!struc_type)
		return;

	qstring file_entry_key;
	qstring key_hash;
	bool filtered = false;

	get_struct_key(struc_type, vtbl_info, file_entry_key, filtered, vtbl_map);
	get_hash_of_string(file_entry_key, key_hash);

	if (filtered)
		return;

	qstring file_entry_val;
	tinfo_t new_type = create_typedef(type_name.c_str());

	if (new_type.is_correct() && new_type.print(&file_entry_val, NULL, PRTYPE_DEF | PRTYPE_1LINE)) {
		qstring line;

		line = key_hash + ";" + file_entry_key + ";";
		line.cat_sprnt("%a;", vtbl_info.ea_begin);
		line += file_entry_val + ";";

		if (rtti_vftables.count(vtbl_info.ea_begin) != 0) {
			VTBL_info_t vi = rtti_vftables[vtbl_info.ea_begin];
			line += vi.vtbl_name;
		}
		line.rtrim();
		line += "\r\n";
		qwrite(file_id, line.c_str(), line.length());
	}
}
Example #6
0
File: devuart.c Project: 8l/inferno
static long
uartwrite(Chan *c, void *buf, long n, vlong offset)
{
	Uart *p;
	char cmd[32];

	USED(offset);

	if(c->qid.type & QTDIR)
		error(Eperm);

	p = uart[NETID(c->qid.path)];

	switch(NETTYPE(c->qid.path)){
	case Ndataqid:
		return qwrite(p->oq, buf, n);
	case Nctlqid:

		if(n >= sizeof(cmd))
			n = sizeof(cmd)-1;
		memmove(cmd, buf, n);
		cmd[n] = 0;
		uartctl(p, cmd);
		return n;
	}
}
Example #7
0
static bool test_all(void){
    test( linux_file_vfs_open() );

    // write
    int fid = qopen( "./a.txt", O_RDWR | O_CREAT | O_TRUNC, NULL );
    test( 0 != fid );
    test( 5 == qwrite( fid, "12345", 5 ) );
    {
        struct qstat buf;
        test( qfstat( fid, &buf ) );
        test( 5 == buf.size );
    }
    test( qclose( fid ) );
    fid = 0;

    // read
    fid = qopen( "./a.txt", O_RDONLY, NULL );
    test( 0 != fid );
    {
        struct qstat buf;
        test( qfstat( fid, &buf ) );
        test( 5 == buf.size );
    }
    char buf[100];
    memset( buf, 0, sizeof( buf ) );
    test( 5 == qread( fid, buf, sizeof(buf) ) );
    test( 0 == memcmp( buf, "12345", 5 ) );
    test( qclose( fid ) );
    fid = 0;

    return true;
}
Example #8
0
File: devcons.c Project: 8l/inferno
static void
flushkbdline(Queue *q)
{
	if(kbd.x){
		qwrite(q, kbd.line, kbd.x);
		kbd.x = 0;
	}
}
Example #9
0
/*
 *  A write to a closed pipe causes an EPIPE error to be thrown.
 */
static long pipewrite(struct chan *c, void *va, long n, int64_t ignored)
{
	ERRSTACK(2);
	Pipe *p;
	//Prog *r;

	if (waserror()) {
		/* avoid exceptions when pipe is a mounted queue */
		if ((c->flag & CMSG) == 0) {
/*
			r = up->iprog;
			if(r != NULL && r->kill == NULL)
				r->kill = "write on closed pipe";
*/
		}
		set_errno(EPIPE);
		nexterror();
	}

	p = c->aux;

	switch (NETTYPE(c->qid.path)) {
		case Qdata0:
			if (c->flag & O_NONBLOCK)
				n = qwrite_nonblock(p->q[1], va, n);
			else
				n = qwrite(p->q[1], va, n);
			break;

		case Qdata1:
			if (c->flag & O_NONBLOCK)
				n = qwrite_nonblock(p->q[0], va, n);
			else
				n = qwrite(p->q[0], va, n);
			break;

		default:
			panic("pipewrite");
	}

	poperror();
	return n;
}
Example #10
0
static void print_to_error_file(const char *error_msg) {
	int file_id = qopen(ERROR_FILE, O_WRONLY | O_APPEND);
	if (file_id == -1)
		file_id = qcreate(ERROR_FILE, 511);

	if (file_id == -1) {
		msg("FATAL: print_to_error_file failed!\n");
		return;
	}

	qwrite(file_id, error_msg, strlen(error_msg));
	qclose(file_id);
}
Example #11
0
static void print_to_output_file(const char *output_msg) {
	int file_id = qopen(OUTPUT_FILE, O_WRONLY | O_APPEND);
	if (file_id == -1)
		file_id = qcreate(OUTPUT_FILE, 511);

	if (file_id == -1) {
		msg("FATAL: print_to_output_file failed!\n");
		return;
	}

	qwrite(file_id, output_msg, strlen(output_msg));
	qclose(file_id);
}
Example #12
0
/*
 *  a write to a closed pipe causes an exception to be sent to
 *  the prog.
 */
static long
pipewrite(Chan *c, void *va, long n, vlong junk)
{
	Pipe *p;

	USED(junk);
	if(waserror()) {
		/* avoid exceptions when pipe is a mounted queue */
		if((c->flag & CMSG) == 0) {
			if (up->ptype == Vm_proc) {
                vproc_t* r = (vproc_t*)up;
                if (r->kill == nil) {
                    r->kill = "write on closed pipe";
                }
            }
		}
		nexterror();
	}

	p = c->aux;

	switch(NETTYPE(c->qid.path)){
	case Qdata0:
		n = qwrite(p->q[1], va, n);
		break;

	case Qdata1:
		n = qwrite(p->q[0], va, n);
		break;

	default:
		panic("pipewrite");
	}

	poperror();
	return n;
}
Example #13
0
static int32_t
uartwrite(Chan *c, void *buf, int32_t n, int64_t mm)
{
	Proc *up = externup();
	Uart *p;
	char *cmd;

	if(c->qid.type & QTDIR)
		error(Eperm);

	p = uart[UARTID(c->qid.path)];

	switch(UARTTYPE(c->qid.path)){
	case Qdata:
		qlock(&p->ql);
		if(waserror()){
			qunlock(&p->ql);
			nexterror();
		}

		n = qwrite(p->oq, buf, n);

		qunlock(&p->ql);
		poperror();
		break;
	case Qctl:
		cmd = malloc(n+1);
		memmove(cmd, buf, n);
		cmd[n] = 0;
		qlock(&p->ql);
		if(waserror()){
			qunlock(&p->ql);
			free(cmd);
			nexterror();
		}

		/* let output drain */
		if(uartctl(p, cmd) < 0)
			error(Ebadarg);

		qunlock(&p->ql);
		poperror();
		free(cmd);
		break;
	}

	return n;
}
Example #14
0
static long
uartwrite(Chan *c, void *buf, long n, vlong)
{
	Uart *p;
	char *cmd;

	if(c->qid.type & QTDIR)
		error(Eperm);

	p = uart[NETID(c->qid.path)];

	switch(NETTYPE(c->qid.path)){
	case Ndataqid:
		qlock(p);
		if(waserror()){
			qunlock(p);
			nexterror();
		}

		n = qwrite(p->oq, buf, n);

		qunlock(p);
		poperror();
		break;
	case Nctlqid:
		cmd = malloc(n+1);
		memmove(cmd, buf, n);
		cmd[n] = 0;
		qlock(p);
		if(waserror()){
			qunlock(p);
			free(cmd);
			nexterror();
		}

		/* let output drain */
		if(uartctl(p, cmd) < 0)
			error(Ebadarg);

		qunlock(p);
		poperror();
		free(cmd);
		break;
	}

	return n;
}
Example #15
0
/* runs on new char in kbd queue */
void readline(uv_async_t* key_wake)
{
    char ch;

    if(qread(kbdq, &ch, 1) == 0) {
         print("null char\n");
    }
    else {
        lsend = 0;
        if(ch == 0){
            /* flush output on rawoff -> rawon */
            if(kbd.x > 0)
                lsend = !qcanread(kbdq);
        }else if(kbd.raw){
            kbd.line[kbd.x++] = ch;
            lsend = !qcanread(kbdq);
        }else{
            switch(ch){
            case '\b':
                if(kbd.x)
                    kbd.x--;
                break;
            case 0x15:
                kbd.x = 0;
                break;
            case 0x04:
                lsend = 1;
                break;
            case '\n':
                lsend = 1;
            default:
                kbd.line[kbd.x++] = ch;
                break;
            }
        }
        if(lsend || kbd.x == sizeof kbd.line){
            uv_mutex_lock(&line_lock);
            qwrite(lineq, kbd.line, kbd.x);
            // signal the queue consumer
            uv_cond_signal(&line_ready);
            uv_mutex_unlock(&line_lock);
            
            kbd.x = 0;
        }
    }
}
Example #16
0
/* ######################################################################### */
static void
writelonglong(char *outfile, LONGLONG a)
{
int i;
unsigned char b[8];

	/* Write integer A one byte at a time to outfile.
	 *
	 * This is portable from Vax to Sun since it eliminates the
	 * need for byte-swapping.
	 */
	for (i=7; i>=0; i--) {
		b[i] = (unsigned char) (a & 0x000000ff);
		a >>= 8;
	}
	for (i=0; i<8; i++) qwrite(outfile, (char *) &b[i],1);
}
Example #17
0
/* ######################################################################### */
static void
writeint(char *outfile, int a)
{
int i;
unsigned char b[4];

	/* Write integer A one byte at a time to outfile.
	 *
	 * This is portable from Vax to Sun since it eliminates the
	 * need for byte-swapping.
	 */
	for (i=3; i>=0; i--) {
		b[i] = a & 0x000000ff;
		a >>= 8;
	}
	for (i=0; i<4; i++) qwrite(outfile, (char *) &b[i],1);
}
void dump_ctrees_in_file(std::map<ea_t, ctree_dump_line> &data_to_dump, qstring &crypto_prefix) {
	int file_id = create_open_file("ctrees.txt");
	if (file_id != -1) {

		size_t crypt_prefix_len = crypto_prefix.length();

		for (std::map<ea_t, ctree_dump_line>::iterator ctrees_iter = data_to_dump.begin(); ctrees_iter != data_to_dump.end() ; ctrees_iter ++) {
			qstring sha_hash;
			int err = get_hash_of_string((*ctrees_iter).second.ctree_for_hash, sha_hash);
			if (err == shaSuccess) {
				qstring dump_line = sha_hash + ";";
				err = get_hash_of_string((*ctrees_iter).second.ctree_dump, sha_hash);
				if (err == shaSuccess) {
					dump_line += sha_hash + ";";
					dump_line += (*ctrees_iter).second.ctree_dump;
					dump_line.cat_sprnt(";%d", (*ctrees_iter).second.func_depth);
					dump_line.cat_sprnt(";%08X", (*ctrees_iter).second.func_start);
					dump_line.cat_sprnt(";%08X", (*ctrees_iter).second.func_end);
					if (((*ctrees_iter).second.func_name.length() > crypt_prefix_len) && (crypt_prefix_len > 0) && ((*ctrees_iter).second.func_name.find(crypto_prefix) == 0))
						dump_line.cat_sprnt(";E", (*ctrees_iter).second.func_end);
					else
						dump_line.cat_sprnt(";N", (*ctrees_iter).second.func_end);
					
					if (((*ctrees_iter).second.heuristic_flag))
						dump_line.cat_sprnt(";H", (*ctrees_iter).second.func_end);
					else
						dump_line.cat_sprnt(";N", (*ctrees_iter).second.func_end);
					
					dump_line += "\n";
				}
				
				qwrite(file_id, dump_line.c_str(), dump_line.length());
					
			} 
			if (err != shaSuccess) {
				logmsg(ERROR, "Error in computing SHA1 hash\r\n");
			}
		}

		qclose(file_id);
	} else {
		logmsg(ERROR, "Failed to open file for dumping ctress\r\n");
	}
}
Example #19
0
void
fsysproc(void *dummy)
{
	u32int i;
	Block *db;

	USED(dummy);

	for(i=0; i<fsys->nblock; i++){
		fsscanblock = i;
		if((db = fsysreadblock(fsys, i)) != nil)
			qwrite(qcmp, db, i);
	}
	fsscanblock = i;
	qclose(qcmp);

	if(statustime)
		print("# %T fsys proc exiting\n");
	runlock(&endlk);
}
Example #20
0
void
cmpproc(void *dummy)
{
	uchar *data;
	Block *db;
	u32int bno, bsize;
	uchar score[VtScoreSize];
	uchar score1[VtScoreSize];

	USED(dummy);

	if(incremental)
		vtfilelock(vscores, VtOREAD);
	bsize = fsys->blocksize;
	while((db = qread(qcmp, &bno)) != nil){
		data = db->data;
		sha1(data, vtzerotruncate(VtDataType, data, bsize), score, nil);
		if(incremental){
			if(vtfileblockscore(vscores, bno, score1) < 0)
				sysfatal("cmpproc vtfileblockscore %d: %r", bno);
		}else{
			if(Bseek(&bscores, (vlong)bno*VtScoreSize, 0) < 0)
				sysfatal("cmpproc Bseek: %r");
			if(Bread(&bscores, score1, VtScoreSize) != VtScoreSize)
				sysfatal("cmpproc Bread: %r");
		}
		if(memcmp(score, score1, VtScoreSize) != 0){
			nchange++;
			if(verbose)
				print("# block %ud: old %V new %V\n", bno, score1, score);
			qwrite(qventi, db, bno);
		}else
			blockput(db);
	}
	qclose(qventi);
	if(incremental)
		vtfileunlock(vscores);
	if(statustime)
		print("# %T cmp proc exiting\n");
	runlock(&endlk);
}
void idaapi dump_type_info(int file_id, VTBL_info_t vtbl_info, qstring type_name, std::map<ea_t, VTBL_info_t> vtbl_map) {
	tid_t type_id = get_struc_id(type_name.c_str());
	if (type_id != BADADDR) {
		struc_t * struc_type = get_struc(type_id);
		if(struc_type != NULL) {
			qstring file_entry_key;
			qstring key_hash;
			bool filtered = false;
			
			get_struct_key(struc_type, vtbl_info, file_entry_key, filtered, vtbl_map);
			get_hash_of_string(file_entry_key, key_hash);

			if (!filtered) {
				qstring file_entry_val;
				tinfo_t new_type = create_typedef(type_name.c_str());
				if(new_type.is_correct()) {
					if (new_type.print(&file_entry_val, NULL, PRTYPE_DEF | PRTYPE_1LINE)) {
						qstring line;

						line = key_hash + ";" + file_entry_key + ";";
						line.cat_sprnt("%p;", vtbl_info.ea_begin);
						line += file_entry_val + ";";
						
						if (rtti_vftables.count(vtbl_info.ea_begin) != 0) {
							vftable::vtinfo vi = rtti_vftables[vtbl_info.ea_begin];
							line += vi.type_info;
						}
						line.rtrim();
						line += "\r\n";
						qwrite(file_id, line.c_str(), line.length());
					}
				}
			}
		}
	}
}
Example #22
0
/*
 *   Print a string on the console.  Convert \n to \r\n for serial
 *   line consoles.  Locking of the queues is left up to the screen
 *   or uart code.  Multi-line messages to serial consoles may get
 *   interspersed with other messages.
 */
static void putstrn0(char *str, int n, int usewrite)
{
	int m;
	char *t;
	char buf[PRINTSIZE + 2];
	ERRSTACK(1);

	/*
	 *  if kprint is open, put the message there, otherwise
	 *  if there's an attached bit mapped display,
	 *  put the message there.
	 */
	m = consoleprint;
	if (canrlock(&(&kprintq)->rwlock)) {
		if (kprintq.q != NULL) {
			if (waserror()) {
				runlock(&(&kprintq)->rwlock);
				nexterror();
			}
			if (usewrite)
				qwrite(kprintq.q, str, n);
			else
				qiwrite(kprintq.q, str, n);
			poperror();
			m = 0;
		}
		runlock(&(&kprintq)->rwlock);
	}
	if (m && screenputs != NULL)
		screenputs(str, n);

	/*
	 *  if there's a serial line being used as a console,
	 *  put the message there.
	 */
	if (serwrite != NULL) {
		serwrite(str, n);
		return;
	}

	if (printq == 0)
		return;

	while (n > 0) {
		t = memchr(str, '\n', n);
		if (t && !kbd.raw) {
			m = t - str;
			if (m > sizeof(buf) - 2)
				m = sizeof(buf) - 2;
			memmove(buf, str, m);
			buf[m] = '\r';
			buf[m + 1] = '\n';
			if (usewrite)
				qwrite(printq, buf, m + 2);
			else
				qiwrite(printq, buf, m + 2);
			str = t + 1;
			n -= m + 1;
		} else {
			if (usewrite)
				qwrite(printq, str, n);
			else
				qiwrite(printq, str, n);
			break;
		}
	}
}
Example #23
0
static int encode(char *outfile, long *nlength, int a[], int nx, int ny, int scale)
{

/* FILE *outfile;  - change outfile to a char array */  
/*
  long * nlength    returned length (in bytes) of the encoded array)
  int a[];								 input H-transform array (nx,ny)
  int nx,ny;								 size of H-transform array	
  int scale;								 scale factor for digitization
*/
int nel, nx2, ny2, i, j, k, q, vmax[3], nsign, bits_to_go;
unsigned char nbitplanes[3];
unsigned char *signbits;
int stat;

        noutchar = 0;  /* initialize the number of compressed bytes that have been written */
	nel = nx*ny;
	/*
	 * write magic value
	 */
	qwrite(outfile, code_magic, sizeof(code_magic));
	writeint(outfile, nx);			/* size of image */
	writeint(outfile, ny);
	writeint(outfile, scale);		/* scale factor for digitization */
	/*
	 * write first value of A (sum of all pixels -- the only value
	 * which does not compress well)
	 */
	writelonglong(outfile, (LONGLONG) a[0]);

	a[0] = 0;
	/*
	 * allocate array for sign bits and save values, 8 per byte
	 */
	signbits = (unsigned char *) malloc((nel+7)/8);
	if (signbits == (unsigned char *) NULL) {
		ffpmsg("encode: insufficient memory");
		return(DATA_COMPRESSION_ERR);
	}
	nsign = 0;
	bits_to_go = 8;
	signbits[0] = 0;
	for (i=0; i<nel; i++) {
		if (a[i] > 0) {
			/*
			 * positive element, put zero at end of buffer
			 */
			signbits[nsign] <<= 1;
			bits_to_go -= 1;
		} else if (a[i] < 0) {
			/*
			 * negative element, shift in a one
			 */
			signbits[nsign] <<= 1;
			signbits[nsign] |= 1;
			bits_to_go -= 1;
			/*
			 * replace a by absolute value
			 */
			a[i] = -a[i];
		}
		if (bits_to_go == 0) {
			/*
			 * filled up this byte, go to the next one
			 */
			bits_to_go = 8;
			nsign += 1;
			signbits[nsign] = 0;
		}
	}
	if (bits_to_go != 8) {
		/*
		 * some bits in last element
		 * move bits in last byte to bottom and increment nsign
		 */
		signbits[nsign] <<= bits_to_go;
		nsign += 1;
	}
	/*
	 * calculate number of bit planes for 3 quadrants
	 *
	 * quadrant 0=bottom left, 1=bottom right or top left, 2=top right, 
	 */
	for (q=0; q<3; q++) {
		vmax[q] = 0;
	}
	/*
	 * get maximum absolute value in each quadrant
	 */
	nx2 = (nx+1)/2;
	ny2 = (ny+1)/2;
	j=0;	/* column counter	*/
	k=0;	/* row counter		*/
	for (i=0; i<nel; i++) {
		q = (j>=ny2) + (k>=nx2);
		if (vmax[q] < a[i]) vmax[q] = a[i];
		if (++j >= ny) {
			j = 0;
			k += 1;
		}
	}
	/*
	 * now calculate number of bits for each quadrant
	 */

        /* this is a more efficient way to do this, */
 
 
        for (q = 0; q < 3; q++) {
            for (nbitplanes[q] = 0; vmax[q]>0; vmax[q] = vmax[q]>>1, nbitplanes[q]++) ; 
        }


/*
	for (q = 0; q < 3; q++) {
		nbitplanes[q] = (int) (log((float) (vmax[q]+1))/log(2.0)+0.5);
		if ( (vmax[q]+1) > (1<<nbitplanes[q]) ) {
			nbitplanes[q] += 1;
		}
	}
*/

	/*
	 * write nbitplanes
	 */
	if (0 == qwrite(outfile, (char *) nbitplanes, sizeof(nbitplanes))) {
	        *nlength = noutchar;
		ffpmsg("encode: output buffer too small");
		return(DATA_COMPRESSION_ERR);
        }
	 
	/*
	 * write coded array
	 */
	stat = doencode(outfile, a, nx, ny, nbitplanes);
	/*
	 * write sign bits
	 */

	if (nsign > 0) {

	   if ( 0 == qwrite(outfile, (char *) signbits, nsign)) {
	        free(signbits);
	        *nlength = noutchar;
		ffpmsg("encode: output buffer too small");
		return(DATA_COMPRESSION_ERR);
          }
	} 
	
	free(signbits);
	*nlength = noutchar;

        if (noutchar >= noutmax) {
		ffpmsg("encode: output buffer too small");
		return(DATA_COMPRESSION_ERR);
        }  
	
	return(stat); 
}
Example #24
0
static long
conswrite(Chan *c, void *va, long n, vlong offset)
{
	char buf[128], *a, ch;
	int x;

	if(c->qid.type & QTDIR)
		error(Eperm);

	switch((ulong)c->qid.path) {
	default:
		error(Egreg);

	case Qcons:
		if(canrlock(&kprintq.l)){
			if(kprintq.q != nil){
				if(waserror()){
					runlock(&kprintq.l);
					nexterror();
				}
				qwrite(kprintq.q, va, n);
				poperror();
				runlock(&kprintq.l);
				return n;
			}
			runlock(&kprintq.l);
		}
		return write(1, va, n);

	case Qsysctl:
		return sysconwrite(va, n);

	case Qconsctl:
		if(n >= sizeof(buf))
			n = sizeof(buf)-1;
		strncpy(buf, va, n);
		buf[n] = 0;
		for(a = buf; a;){
			if(strncmp(a, "rawon", 5) == 0){
				kbd.raw = 1;
				/* clumsy hack - wake up reader */
				ch = 0;
				qwrite(kbdq, &ch, 1);
			} else if(strncmp(buf, "rawoff", 6) == 0){
				kbd.raw = 0;
			}
			if((a = strchr(a, ' ')) != nil)
				a++;
		}
		break;

	case Qkeyboard:
		for(x=0; x<n; ) {
			Rune r;
			x += chartorune(&r, &((char*)va)[x]);
			gkbdputc(gkbdq, r);
		}
		break;

	case Qnull:
		break;

	case Qtime:
		if(n >= sizeof(buf))
			n = sizeof(buf)-1;
		strncpy(buf, va, n);
		buf[n] = '\0';
		timeoffset = strtoll(buf, 0, 0)-osusectime();
		break;

	case Qhostowner:
		if(!iseve())
			error(Eperm);
		if(offset != 0 || n >= sizeof(buf))
			error(Ebadarg);
		memmove(buf, va, n);
		buf[n] = '\0';
		if(n > 0 && buf[n-1] == '\n')
			buf[--n] = '\0';
		if(n == 0)
			error(Ebadarg);
		/* renameuser(eve, buf); */
		/* renameproguser(eve, buf); */
		kstrdup(&eve, buf);
		kstrdup(&up->env->user, buf);
		break;

	case Quser:
		if(!iseve())
			error(Eperm);
		if(offset != 0)
			error(Ebadarg);
		if(n <= 0 || n >= sizeof(buf))
			error(Ebadarg);
		strncpy(buf, va, n);
		buf[n] = '\0';
		if(n > 0 && buf[n-1] == '\n')
			buf[--n] = '\0';
		if(n == 0)
			error(Ebadarg);
		setid(buf, 0);
		break;

	case Qhoststdout:
		return write(1, va, n);

	case Qhoststderr:
		return write(2, va, n);

	case Qjit:
		if(n >= sizeof(buf))
			n = sizeof(buf)-1;
		strncpy(buf, va, n);
		buf[n] = '\0';
		x = atoi(buf);
		if(x < 0 || x > 9)
			error(Ebadarg);
		cflag = x;
		break;

	case Qsysname:
		if(offset != 0)
			error(Ebadarg);
		if(n < 0 || n >= sizeof(buf))
			error(Ebadarg);
		strncpy(buf, va, n);
		buf[n] = '\0';
		if(buf[n-1] == '\n')
			buf[n-1] = 0;
		kstrdup(&ossysname, buf);
		break;
	}
	return n;
}
Example #25
0
static long
consread(Chan *c, void *va, long n, vlong offset)
{
	int send;
	char buf[64], ch;

	if(c->qid.type & QTDIR)
		return devdirread(c, va, n, contab, nelem(contab), devgen);

	switch((ulong)c->qid.path) {
	default:
		error(Egreg);

	case Qsysctl:
		return readstr(offset, va, n, VERSION);

	case Qsysname:
		if(ossysname == nil)
			return 0;
		return readstr(offset, va, n, ossysname);

	case Qrandom:
		return randomread(va, n);

	case Qnotquiterandom:
		genrandom(va, n);
		return n;

	case Qhostowner:
		return readstr(offset, va, n, eve);

	case Qhoststdin:
		return read(0, va, n);	/* should be pread */

	case Quser:
		return readstr(offset, va, n, up->env->user);

	case Qjit:
		snprint(buf, sizeof(buf), "%d", cflag);
		return readstr(offset, va, n, buf);

	case Qtime:
		snprint(buf, sizeof(buf), "%.lld", timeoffset + osusectime());
		return readstr(offset, va, n, buf);

	case Qdrivers:
		return devtabread(c, va, n, offset);

	case Qmemory:
		return poolread(va, n, offset);

	case Qnull:
		return 0;

	case Qmsec:
		return readnum(offset, va, n, osmillisec(), NUMSIZE);

	case Qcons:
		qlock(&kbd.q);
		if(waserror()){
			qunlock(&kbd.q);
			nexterror();
		}

		if(dflag)
			error(Enonexist);

		while(!qcanread(lineq)) {
			if(qread(kbdq, &ch, 1) == 0)
				continue;
			send = 0;
			if(ch == 0){
				/* flush output on rawoff -> rawon */
				if(kbd.x > 0)
					send = !qcanread(kbdq);
			}else if(kbd.raw){
				kbd.line[kbd.x++] = ch;
				send = !qcanread(kbdq);
			}else{
				switch(ch){
				case '\b':
					if(kbd.x)
						kbd.x--;
					break;
				case 0x15:
					kbd.x = 0;
					break;
				case 0x04:
					send = 1;
					break;
				case '\n':
					send = 1;
				default:
					kbd.line[kbd.x++] = ch;
					break;
				}
			}
			if(send || kbd.x == sizeof kbd.line){
				qwrite(lineq, kbd.line, kbd.x);
				kbd.x = 0;
			}
		}
		n = qread(lineq, va, n);
		qunlock(&kbd.q);
		poperror();
		return n;

	case Qscancode:
		if(offset == 0)
			return readstr(0, va, n, gkscanid);
		return qread(gkscanq, va, n);

	case Qkeyboard:
		return qread(gkbdq, va, n);

	case Qkprint:
		rlock(&kprintq.l);
		if(waserror()){
			runlock(&kprintq.l);
			nexterror();
		}
		n = qread(kprintq.q, va, n);
		poperror();
		runlock(&kprintq.l);
		return n;
	}
}
Example #26
0
static void cb(am_device_notification_callback_info * info, void *foo)
{
	struct am_device *dev;

	if (info->msg == ADNCI_MSG_CONNECTED) {
		dev = info->dev;

		AMDeviceConnect(dev);
		assert(AMDeviceIsPaired(dev));
		assert(!AMDeviceValidatePairing(dev));
		assert(!AMDeviceStartSession(dev));

		CFStringRef product =
		    AMDeviceCopyValue(dev, 0, CFSTR("ProductVersion"));
		assert(product);
		UniChar first = CFStringGetCharacterAtIndex(product, 0);
		int epoch = first - '0';
Retry:	{}
		printf("Attempting to mount image...\n");

		service_conn_t afc_socket = 0;
		struct afc_connection *afc = NULL;
		assert(!AMDeviceStartService(dev, CFSTR("com.apple.afc"), &afc_socket, NULL));
		assert(!AFCConnectionOpen(afc_socket, 0, &afc));
		assert(!AFCDirectoryCreate(afc, "PublicStaging"));

		AFCRemovePath(afc, "PublicStaging/staging.dimage");
		qwrite(afc, real_dmg, "PublicStaging/staging.dimage");
		qwrite(afc, ddi_dmg, "PublicStaging/ddi.dimage");

		service_conn_t mim_socket1 = 0;
		service_conn_t mim_socket2 = 0;
		assert(!AMDeviceStartService(dev, CFSTR("com.apple.mobile.mobile_image_mounter"), &mim_socket1, NULL));
		assert(mim_socket1);

		CFPropertyListRef result = NULL;
		CFMutableDictionaryRef dict = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
		CFDictionarySetValue(dict, CFSTR("Command"), CFSTR("MountImage"));
		CFDictionarySetValue(dict, CFSTR("ImageType"), CFSTR("Developer"));

		CFDictionarySetValue(dict, CFSTR("ImagePath"), CFSTR("/var/mobile/Media/PublicStaging/staging.dimage"));

		int fd = open(real_dmg_signature, O_RDONLY);
		assert(fd != -1);
		uint8_t sig[128];
		assert(read(fd, sig, sizeof(sig)) == sizeof(sig));
		close(fd);

		CFDictionarySetValue(dict, CFSTR("ImageSignature"), CFDataCreateWithBytesNoCopy(NULL, sig, sizeof(sig), kCFAllocatorNull));
		send_message(mim_socket1, dict);

		usleep(timesl);
		assert(!AFCRenamePath(afc, "PublicStaging/ddi.dimage", "PublicStaging/staging.dimage"));

		result = receive_message(mim_socket1);

		int len = CFDataGetLength(CFPropertyListCreateXMLData(NULL, result));
		char* bytes = CFDataGetBytePtr(CFPropertyListCreateXMLData(NULL, result));

		if(strstr(bytes, "Complete")) {
			char* the_service = "CopyIt";
			service_conn_t socket = 0;
			sleep(2);
			printf("Image mounted, running helper...\n");
			assert(!AMDeviceStartService(dev, CFStringCreateWithCStringNoCopy(NULL, the_service, kCFStringEncodingUTF8, kCFAllocatorNull),
				&socket, NULL));
			assert(!fcntl(socket, F_SETFL, O_NONBLOCK));
			assert(!fcntl(0, F_SETFL, O_NONBLOCK));
		} else {
			printf("Failed to inject image, trying again... (if it fails, try a different time), delay ... %dus\n", timesl);
			timesl += 1000;
			goto Retry;
		}

		exit(0);
	}
}
Example #27
0
File: devcons.c Project: 8l/inferno
static long
consread(Chan *c, void *buf, long n, vlong offset)
{
	int l;
	Osenv *o;
	int ch, eol, i;
	char *p, tmp[128];
	char *cbuf = buf;

	if(n <= 0)
		return n;
	o = up->env;
	switch((ulong)c->qid.path){
	case Qdir:
		return devdirread(c, buf, n, consdir, nelem(consdir), devgen);
	case Qsysctl:
		return readstr(offset, buf, n, VERSION);
	case Qcons:
	case Qkeyboard:
		qlock(&kbd);
		if(waserror()) {
			qunlock(&kbd);
			nexterror();
		}
		if(kbd.raw || kbd.kbdr) {
			if(qcanread(lineq))
				n = qread(lineq, buf, n);
			else {
				/* read as much as possible */
				do {
					i = qread(kbdq, cbuf, n);
					cbuf += i;
					n -= i;
				} while(n>0 && qcanread(kbdq));
				n = cbuf - (char*)buf;
			}
		} else {
			while(!qcanread(lineq)) {
				qread(kbdq, &kbd.line[kbd.x], 1);
				ch = kbd.line[kbd.x];
				eol = 0;
				switch(ch){
				case '\b':
					if(kbd.x)
						kbd.x--;
					break;
				case 0x15:
					kbd.x = 0;
					break;
				case '\n':
				case 0x04:
					eol = 1;
				default:
					kbd.line[kbd.x++] = ch;
					break;
				}
				if(kbd.x == sizeof(kbd.line) || eol) {
					if(ch == 0x04)
						kbd.x--;
					qwrite(lineq, kbd.line, kbd.x);
					kbd.x = 0;
				}
			}
			n = qread(lineq, buf, n);
		}
		qunlock(&kbd);
		poperror();
		return n;

	case Qscancode:
		if(offset == 0)
			return readstr(0, buf, n, kscanid);
		else
			return qread(kscanq, buf, n);

	case Qtime:
		snprint(tmp, sizeof(tmp), "%.lld", (vlong)mseconds()*1000);
		return readstr(offset, buf, n, tmp);

	case Qhostowner:
		return readstr(offset, buf, n, eve);

	case Quser:
		return readstr(offset, buf, n, o->user);

	case Qjit:
		snprint(tmp, sizeof(tmp), "%d", cflag);
		return readstr(offset, buf, n, tmp);

	case Qnull:
		return 0;

	case Qmsec:
		return readnum(offset, buf, n, TK2MS(MACHP(0)->ticks), NUMSIZE);

	case Qsysname:
		if(sysname == nil)
			return 0;
		return readstr(offset, buf, n, sysname);

	case Qnotquiterandom:
		genrandom(buf, n);
		return n;

	case Qrandom:
		return randomread(buf, n);

	case Qmemory:
		return poolread(buf, n, offset);

	case Qdrivers:
		p = malloc(READSTR);
		if(p == nil)
			error(Enomem);
		l = 0;
		for(i = 0; devtab[i] != nil; i++)
			l += snprint(p+l, READSTR-l, "#%C %s\n", devtab[i]->dc,  devtab[i]->name);
		if(waserror()){
			free(p);
			nexterror();
		}
		n = readstr(offset, buf, n, p);
		free(p);
		poperror();
		return n;

	case Qklog:
		return qread(klogq, buf, n);

	case Qkprint:
		rlock(&kprintq);
		if(waserror()){
			runlock(&kprintq);
			nexterror();
		}
		n = qread(kprintq.q, buf, n);
		poperror();
		runlock(&kprintq);
		return n;

	default:
		print("consread %llud\n", c->qid.path);
		error(Egreg);
	}
	return -1;		/* never reached */
}
Example #28
0
static long conswrite(struct chan *c, void *va, long n, int64_t off)
{
    ERRSTACK(1);
    char buf[256], ch;
    long l, bp;
    char *a;
    //Mach *mp;
    int id, fd;
    struct chan *swc;
    uint32_t offset;
    struct cmdbuf *cb;
    struct cmdtab *ct;
    int x;
    uint64_t rip, rsp, cr3, flags, vcpu;
    int ret;
    struct vmctl vmctl;

    a = va;
    offset = off;

    switch ((uint32_t) c->qid.path) {
    case Qcons:
        /*
         * Can't page fault in putstrn, so copy the data locally.
         */
        l = n;
        while (l > 0) {
            bp = l;
            if (bp > sizeof buf)
                bp = sizeof buf;
            memmove(buf, a, bp);
            putstrn0(buf, bp, 1);
            a += bp;
            l -= bp;
        }
        break;

    case Qconsctl:
        if (n >= sizeof(buf))
            n = sizeof(buf) - 1;
        strncpy(buf, a, n);
        buf[n] = 0;
        for (a = buf; a;) {
            if (strncmp(a, "rawon", 5) == 0) {
                kbd.raw = 1;
                /* clumsy hack - wake up reader */
                ch = 0;
                qwrite(kbdq, &ch, 1);
            } else if (strncmp(a, "rawoff", 6) == 0) {
                kbd.raw = 0;
            } else if (strncmp(a, "ctlpon", 6) == 0) {
                kbd.ctlpoff = 0;
            } else if (strncmp(a, "ctlpoff", 7) == 0) {
                kbd.ctlpoff = 1;
            }
            if ((a = strchr(a, ' ')) != NULL)
                a++;
        }
        break;

    case Qtime:
        if (!iseve())
            error(EPERM, "Hodie Natus Est Radici Frater");
        return writetime(a, n);

    case Qbintime:
        if (!iseve())
            error(EPERM, ERROR_FIXME);
        return writebintime(a, n);

#if 0
    case Qhostowner:
        return hostownerwrite(a, n);

    case Qhostdomain:
        return hostdomainwrite(a, n);

    case Quser:
        return userwrite(a, n);
#endif

    case Qnull:
        break;

    case Qconfig:
        error(EPERM, "Cannot write to config QID");
        break;

    case Qsysctl:
        //if (!iseve()) error(EPERM, ERROR_FIXME);
        cb = parsecmd(a, n);
        if (cb->nf > 1)
            printd("cons sysctl cmd %s\n", cb->f[0]);

    case Qreboot:
        if (!iseve())
            error(EPERM, ERROR_FIXME);
        cb = parsecmd(a, n);

        if (waserror()) {
            kfree(cb);
            nexterror();
        }
        ct = lookupcmd(cb, rebootmsg, ARRAY_SIZE(rebootmsg));
        switch (ct->index) {
        case CMhalt:
            cpu_halt();
            break;
        case CMbroken:
            keepbroken = 1;
            break;
        case CMnobroken:
            keepbroken = 0;
            break;
        case CMreboot:
            reboot();
            break;
        case CMpanic:
            *(uint32_t *) 0 = 0;
            panic("/dev/reboot");
        }
        poperror();
        kfree(cb);
        break;

#if 0
    case Qsysstat:
        for (id = 0; id < 32; id++) {
            if (active.machs & (1 << id)) {
                mp = MACHP(id);
                mp->cs = 0;
                mp->intr = 0;
                mp->syscall = 0;
                mp->pfault = 0;
                mp->tlbfault = 0;
                mp->tlbpurge = 0;
            }
        }
        break;

    case Qswap:
        if (n >= sizeof buf)
            error(EINVAL, "n is bigger than sizeof buf for Qswap");
        memmove(buf, va, n);	/* so we can NUL-terminate */
        buf[n] = 0;
        /* start a pager if not already started */
        if (strncmp(buf, "start", 5) == 0) {
            kickpager();
            break;
        }
        if (!iseve())
            error(EPERM, ERROR_FIXME);
        if (buf[0] < '0' || '9' < buf[0])
            error(EINVAL, ERROR_FIXME);
        fd = strtoul(buf, 0, 0);
        swc = fdtochan(fd, -1, 1, 1);
        setswapchan(swc);
        break;
#endif

    case Qsysname:
        if (offset != 0)
            error(EINVAL, ERROR_FIXME);
        if (n <= 0 || n >= sizeof buf)
            error(EINVAL, ERROR_FIXME);
        strncpy(buf, a, n);
        buf[n] = 0;
        if (buf[n - 1] == '\n')
            buf[n - 1] = 0;
        kstrdup(&sysname, buf);
        break;

    default:
        printd("conswrite: %#llux\n", c->qid.path);
        error(EINVAL, "bad QID in conswrite");
    }
    return n;
}
Example #29
0
static long consread(struct chan *c, void *buf, long n, int64_t off)
{
    ERRSTACK(1);
    uint32_t l;
#if 0
    Mach *mp;
#endif
    char *b, *bp, ch;
    char tmp[256];				/* must be >= 18*NUMSIZE (Qswap) */
    int i, k, id, send;
    int64_t offset = off;
#if 0
    extern char configfile[];
#endif

    if (n <= 0)
        return n;

    switch ((uint32_t) c->qid.path) {
    case Qdir:
        return devdirread(c, buf, n, consdir, ARRAY_SIZE(consdir), devgen);

    case Qcons:
        qlock(&(&kbd)->qlock);
        if (waserror()) {
            qunlock(&(&kbd)->qlock);
            nexterror();
        }
        while (!qcanread(lineq)) {
            if (qread(kbdq, &ch, 1) == 0)
                continue;
            send = 0;
            if (ch == 0) {
                /* flush output on rawoff -> rawon */
                if (kbd.x > 0)
                    send = !qcanread(kbdq);
            } else if (kbd.raw) {
                kbd.line[kbd.x++] = ch;
                send = !qcanread(kbdq);
            } else {
                switch (ch) {
                case '\b':
                    if (kbd.x > 0)
                        kbd.x--;
                    break;
                case 0x15:	/* ^U */
                    kbd.x = 0;
                    break;
                case '\n':
                case 0x04:	/* ^D */
                    send = 1;
                default:
                    if (ch != 0x04)
                        kbd.line[kbd.x++] = ch;
                    break;
                }
            }
            if (send || kbd.x == sizeof kbd.line) {
                qwrite(lineq, kbd.line, kbd.x);
                kbd.x = 0;
            }
        }
        n = qread(lineq, buf, n);
        qunlock(&(&kbd)->qlock);
        poperror();
        return n;

#if 0
    case Qcputime:
        k = offset;
        if (k >= 6 * NUMSIZE)
            return 0;
        if (k + n > 6 * NUMSIZE)
            n = 6 * NUMSIZE - k;
        /* easiest to format in a separate buffer and copy out */
        for (i = 0; i < 6 && NUMSIZE * i < k + n; i++) {
            l = current->time[i];
            if (i == TReal)
                l = MACHP(0)->ticks - l;
            l = TK2MS(l);
            consreadnum(0, tmp + NUMSIZE * i, NUMSIZE, l, NUMSIZE);
        }
        memmove(buf, tmp + k, n);
        return n;
#endif

    case Qkmesg:
        /*
         * This is unlocked to avoid tying up a process
         * that's writing to the buffer.  kmesg.n never
         * gets smaller, so worst case the reader will
         * see a slurred buffer.
         */
        if (off >= kmesg.n)
            n = 0;
        else {
            if (off + n > kmesg.n)
                n = kmesg.n - off;
            memmove(buf, kmesg.buf + off, n);
        }
        return n;

    case Qkprint:
        return qread(kprintoq, buf, n);

    case Qpgrpid:
        return consreadnum((uint32_t) offset, buf, n, current->pgrp->pgrpid,
                           NUMSIZE);

    case Qpid:
        return consreadnum((uint32_t) offset, buf, n, current->pid,
                           NUMSIZE);

    case Qppid:
        return consreadnum((uint32_t) offset, buf, n, current->ppid,
                           NUMSIZE);

    case Qtime:
        return readtime((uint32_t) offset, buf, n);

    case Qbintime:
        return readbintime(buf, n);

    case Qhostowner:
        return consreadstr((uint32_t) offset, buf, n, eve);

    case Qhostdomain:
        return consreadstr((uint32_t) offset, buf, n, hostdomain);

    case Quser:
        return consreadstr((uint32_t) offset, buf, n, current->user);

    case Qnull:
        return 0;

#if 0
    case Qconfig:
        return consreadstr((uint32_t) offset, buf, n, configfile);

    case Qsysstat:
        b = kzmalloc(conf.nmach * (NUMSIZE * 11 + 1) + 1, 0);	/* +1 for NUL */
        bp = b;
        for (id = 0; id < 32; id++) {
            if (active.machs & (1 << id)) {
                mp = MACHP(id);
                consreadnum(0, bp, NUMSIZE, id, NUMSIZE);
                bp += NUMSIZE;
                consreadnum(0, bp, NUMSIZE, mp->cs, NUMSIZE);
                bp += NUMSIZE;
                consreadnum(0, bp, NUMSIZE, mp->intr, NUMSIZE);
                bp += NUMSIZE;
                consreadnum(0, bp, NUMSIZE, mp->syscall, NUMSIZE);
                bp += NUMSIZE;
                consreadnum(0, bp, NUMSIZE, mp->pfault, NUMSIZE);
                bp += NUMSIZE;
                consreadnum(0, bp, NUMSIZE, mp->tlbfault, NUMSIZE);
                bp += NUMSIZE;
                consreadnum(0, bp, NUMSIZE, mp->tlbpurge, NUMSIZE);
                bp += NUMSIZE;
                consreadnum(0, bp, NUMSIZE, mp->load, NUMSIZE);
                bp += NUMSIZE;
                consreadnum(0, bp, NUMSIZE,
                            (mp->perf.avg_inidle * 100) / mp->perf.period,
                            NUMSIZE);
                bp += NUMSIZE;
                consreadnum(0, bp, NUMSIZE,
                            (mp->perf.avg_inintr * 100) / mp->perf.period,
                            NUMSIZE);
                bp += NUMSIZE;
                *bp++ = '\n';
            }
        }
        if (waserror()) {
            kfree(b);
            nexterror();
        }
        n = consreadstr((uint32_t) offset, buf, n, b);
        kfree(b);
        poperror();
        return n;

    case Qswap:
        snprintf(tmp, sizeof tmp,
                 "%lud memory\n"
                 "%d pagesize\n"
                 "%lud kernel\n"
                 "%lud/%lud user\n"
                 "%lud/%lud swap\n"
                 "%lud/%lud kernel malloc\n"
                 "%lud/%lud kernel draw\n",
                 conf.npage * BY2PG,
                 BY2PG,
                 conf.npage - conf.upages,
                 palloc.user - palloc.freecount, palloc.user,
                 conf.nswap - swapalloc.free, conf.nswap,
                 mainmem->cursize, mainmem->maxsize,
                 imagmem->cursize, imagmem->maxsize);

        return consreadstr((uint32_t) offset, buf, n, tmp);
#endif

    case Qsysname:
        if (sysname == NULL)
            return 0;
        return consreadstr((uint32_t) offset, buf, n, sysname);

    case Qdrivers:
        b = kzmalloc(READSTR, 0);
        if (b == NULL)
            error(ENOMEM, "allocation for /dev/drivers read failed");
        k = 0;
        for (int i = 0; &devtab[i] < __devtabend; i++)
            k += snprintf(b + k, READSTR - k, "#%s\n", devtab[i].name);
        if (waserror()) {
            kfree(b);
            nexterror();
        }
        n = consreadstr((uint32_t) offset, buf, n, b);
        kfree(b);
        poperror();
        return n;

    case Qklog:
        //return qread(klogq, buf, n);
        /* the queue gives us some elasticity for log reading. */
        if (!logqueue)
            logqueue = qopen(1 << 20, 0, 0, 0);
        if (logqueue) {
            int ret;
            /* atomic sets/gets are not that important in this case. */
            reading_kmesg = 1;
            qwrite(logqueue, logbuffer, index);
            index = 0;
            ret = qread(logqueue, buf, n);
            reading_kmesg = 0;
            return ret;
        }
        break;

    case Qzero:
        memset(buf, 0, n);
        return n;

    case Qosversion:
        snprintf(tmp, sizeof tmp, "2000");
        n = consreadstr((uint32_t) offset, buf, n, tmp);
        return n;

    default:
        printd("consread %#llux\n", c->qid.path);
        error(EINVAL, "bad QID in consread");
    }
    return -1;	/* never reached */
}
Example #30
0
static long
ipwrite(Chan* ch, void *v, long n, vlong off)
{
	Conv *c;
	Proto *x;
	char *p;
	Cmdbuf *cb;
	uchar ia[IPaddrlen], ma[IPaddrlen];
	Fs *f;
	char *a;
	ulong offset = off;

	a = v;
	f = ipfs[ch->dev];

	switch(TYPE(ch->qid)){
	default:
		error(Eperm);
	case Qdata:
		x = f->p[PROTO(ch->qid)];
		c = x->conv[CONV(ch->qid)];

		if(c->wq == nil)
			error(Eperm);

		qwrite(c->wq, a, n);
		break;
	case Qarp:
		return arpwrite(f, a, n);
	case Qiproute:
		return routewrite(f, ch, a, n);
	case Qlog:
		netlogctl(f, a, n);
		return n;
	case Qndb:
		return ndbwrite(f, a, offset, n);
		break;
	case Qctl:
		x = f->p[PROTO(ch->qid)];
		c = x->conv[CONV(ch->qid)];
		cb = parsecmd(a, n);

		qlock(c);
		if(waserror()) {
			qunlock(c);
			free(cb);
			nexterror();
		}
		if(cb->nf < 1)
			error("short control request");
		if(strcmp(cb->f[0], "connect") == 0)
			connectctlmsg(x, c, cb);
		else if(strcmp(cb->f[0], "announce") == 0)
			announcectlmsg(x, c, cb);
		else if(strcmp(cb->f[0], "bind") == 0)
			bindctlmsg(x, c, cb);
		else if(strcmp(cb->f[0], "ttl") == 0)
			ttlctlmsg(c, cb);
		else if(strcmp(cb->f[0], "tos") == 0)
			tosctlmsg(c, cb);
		else if(strcmp(cb->f[0], "ignoreadvice") == 0)
			c->ignoreadvice = 1;
		else if(strcmp(cb->f[0], "addmulti") == 0){
			if(cb->nf < 2)
				error("addmulti needs interface address");
			if(cb->nf == 2){
				if(!ipismulticast(c->raddr))
					error("addmulti for a non multicast address");
				if (parseip(ia, cb->f[1]) == -1)
					error(Ebadip);
				ipifcaddmulti(c, c->raddr, ia);
			} else {
				if (parseip(ia, cb->f[1]) == -1 ||
				    parseip(ma, cb->f[2]) == -1)
					error(Ebadip);
				if(!ipismulticast(ma))
					error("addmulti for a non multicast address");
				ipifcaddmulti(c, ma, ia);
			}
		} else if(strcmp(cb->f[0], "remmulti") == 0){
			if(cb->nf < 2)
				error("remmulti needs interface address");
			if(!ipismulticast(c->raddr))
				error("remmulti for a non multicast address");
			if (parseip(ia, cb->f[1]) == -1)
				error(Ebadip);
			ipifcremmulti(c, c->raddr, ia);
		} else if(strcmp(cb->f[0], "maxfragsize") == 0){
			if(cb->nf < 2)
				error("maxfragsize needs size");

			c->maxfragsize = (int)strtol(cb->f[1], nil, 0);

		} else if(x->ctl != nil) {
			p = x->ctl(c, cb->f, cb->nf);
			if(p != nil)
				error(p);
		} else
			error("unknown control request");
		qunlock(c);
		free(cb);
		poperror();
	}
	return n;
}