示例#1
0
void test_stream(void)
{
	STREAM * stream;
	int pos;
	uint32 n;
	uint64 n64;

	stream = stream_new(1);
	pos = stream_get_pos(stream);

	stream_write_uint8(stream, 0xFE);

	stream_check_size(stream, 14);
	stream_write_uint16(stream, 0x0102);
	stream_write_uint32(stream, 0x03040506);
	stream_write_uint64(stream, 0x0708091011121314LL);

	/* freerdp_hexdump(stream->buffer, 15); */

	stream_set_pos(stream, pos);
	stream_seek(stream, 3);
	stream_read_uint32(stream, n);
	stream_read_uint64(stream, n64);

	CU_ASSERT(n == 0x03040506);
	CU_ASSERT(n64 == 0x0708091011121314LL);

	stream_free(stream);
}
示例#2
0
static void printer_process_irp_write(PRINTER_DEVICE* printer_dev, IRP* irp) {
	rdpPrintJob* printjob = NULL;
	uint32 Length;
	uint64 Offset;

	stream_read_uint32(irp->input, Length);
	stream_read_uint64(irp->input, Offset);
	(void) Offset;
	stream_seek(irp->input, 20);
	/* Padding */

	if (printer_dev->printer != NULL)
		printjob = printer_dev->printer->FindPrintJob(printer_dev->printer, irp->FileId);

	if (printjob == NULL) {
		irp->IoStatus = STATUS_UNSUCCESSFUL;
		Length = 0;

		log_warning("printjob id %d not found.", irp->FileId);
	} else {
		printjob->Write(printjob, stream_get_tail(irp->input), Length);

		log_debug("printjob id %d written %d bytes.", irp->FileId, Length);
	}

	stream_write_uint32(irp->output, Length);
	stream_write_uint8(irp->output, 0);
	/* Padding */

	irp->Complete(irp);
}
示例#3
0
/* http://msdn.microsoft.com/en-us/library/dd390700.aspx */
static uint32 tsmf_codec_parse_VIDEOINFOHEADER(TS_AM_MEDIA_TYPE* mediatype, STREAM* s)
{
/*
typedef struct tagVIDEOINFOHEADER {
  RECT             rcSource;			//16
  RECT             rcTarget;			//16	32
  DWORD            dwBitRate;			//4	36
  DWORD            dwBitErrorRate;		//4	40
  REFERENCE_TIME   AvgTimePerFrame;		//8	48
  BITMAPINFOHEADER bmiHeader;
} VIDEOINFOHEADER;
*/
	uint64 AvgTimePerFrame;

	/* VIDEOINFOHEADER.rcSource, RECT(LONG left, LONG top, LONG right, LONG bottom) */
	stream_seek_uint32(s);
	stream_seek_uint32(s);
	stream_read_uint32(s, mediatype->Width);
	stream_read_uint32(s, mediatype->Height);
	/* VIDEOINFOHEADER.rcTarget */
	stream_seek(s, 16);
	/* VIDEOINFOHEADER.dwBitRate */
	stream_read_uint32(s, mediatype->BitRate);
	/* VIDEOINFOHEADER.dwBitErrorRate */
	stream_seek_uint32(s);
	/* VIDEOINFOHEADER.AvgTimePerFrame */
	stream_read_uint64(s, AvgTimePerFrame);
	mediatype->SamplesPerSecond.Numerator = 1000000;
	mediatype->SamplesPerSecond.Denominator = (int)(AvgTimePerFrame / 10LL);

	return 48;
}
示例#4
0
static void serial_process_irp_read(SERIAL_DEVICE* serial, IRP* irp)
{
    SERIAL_TTY* tty;
    uint32 Length;
    uint64 Offset;
    uint8* buffer = NULL;

    stream_read_uint32(irp->input, Length);
    stream_read_uint64(irp->input, Offset);

    DEBUG_SVC("length %u offset %llu", Length, Offset);

    tty = serial->tty;
    if (tty == NULL)
    {
        irp->IoStatus = STATUS_UNSUCCESSFUL;
        Length = 0;

        DEBUG_WARN("tty not valid.");
    }
    else
    {
        buffer = (uint8*)xmalloc(Length);
        if (!serial_tty_read(tty, buffer, &Length))
        {
            irp->IoStatus = STATUS_UNSUCCESSFUL;
            xfree(buffer);
            buffer = NULL;
            Length = 0;

            DEBUG_WARN("read %s(%d) failed.", serial->path, tty->id);
        }
        else
        {
            DEBUG_SVC("read %llu-%llu from %d", Offset, Offset + Length, tty->id);
        }
    }

    stream_write_uint32(irp->output, Length);
    if (Length > 0)
    {
        stream_check_size(irp->output, Length);
        stream_write(irp->output, buffer, Length);
    }
    xfree(buffer);

    irp->Complete(irp);
}
示例#5
0
static lua_module_t
lua_module_load_resource(const uuid_t uuid) {
	lua_module_t module = {0, 0};
	bool success = false;
	const uint32_t expected_version = 1;
	uint64_t platform = 0;
	stream_t* stream;

	stream = resource_stream_open_static(uuid, platform);
	if (stream) {
		resource_header_t header = resource_stream_read_header(stream);
		if ((header.type == HASH_LUA) && (header.version == expected_version)) {
			success = true;
		}
		else {
			log_warnf(HASH_LUA, WARNING_INVALID_VALUE,
			          STRING_CONST("Got unexpected type/version when loading Lua module: %" PRIx64 " : %u"),
			          header.type, header.version);
		}
		stream_deallocate(stream);
		stream = nullptr;
	}
	if (success)
		stream = resource_stream_open_dynamic(uuid, platform);
	if (stream) {
		uint32_t version = stream_read_uint32(stream);
		size_t size = (size_t)stream_read_uint64(stream);
		if (version == expected_version) {
			void* buffer = memory_allocate(HASH_LUA, size, 0, MEMORY_TEMPORARY);
			if (stream_read(stream, buffer, size) == size) {
				module.bytecode = buffer;
				module.size = size;
			}
			else {
				memory_deallocate(buffer);
			}
		}
		else {
			log_warnf(HASH_LUA, WARNING_INVALID_VALUE,
			          STRING_CONST("Got unexpected type/version when loading Lua module blob: %u"),
			          version);
		}
		stream_deallocate(stream);
		stream = nullptr;
	}

	return module;
}
示例#6
0
static void parallel_process_irp_read(PARALLEL_DEVICE* parallel, IRP* irp)
{
    uint32 Length;
    uint64 Offset;
    ssize_t status;
    uint8* buffer = NULL;

    stream_read_uint32(irp->input, Length);
    stream_read_uint64(irp->input, Offset);

    buffer = (uint8*) xmalloc(Length);

    status = read(parallel->file, irp->output->p, Length);

    if (status < 0)
    {
        irp->IoStatus = STATUS_UNSUCCESSFUL;
        xfree(buffer);
        buffer = NULL;
        Length = 0;

        DEBUG_WARN("read %s(%d) failed", parallel->path, parallel->id);
    }
    else
    {
        DEBUG_SVC("read %llu-%llu from %d", Offset, Offset + Length, parallel->id);
    }

    stream_write_uint32(irp->output, Length);
    if (Length > 0)
    {
        stream_check_size(irp->output, Length);
        stream_write(irp->output, buffer, Length);
    }
    xfree(buffer);

    irp->Complete(irp);
}
示例#7
0
static void serial_process_irp_write(SERIAL_DEVICE* serial, IRP* irp)
{
    SERIAL_TTY* tty;
    uint32 Length;
    uint64 Offset;

    stream_read_uint32(irp->input, Length);
    stream_read_uint64(irp->input, Offset);
    stream_seek(irp->input, 20); /* Padding */

    DEBUG_SVC("length %u offset %llu", Length, Offset);

    tty = serial->tty;
    if (tty == NULL)
    {
        irp->IoStatus = STATUS_UNSUCCESSFUL;
        Length = 0;

        DEBUG_WARN("tty not valid.");
    }
    else if (!serial_tty_write(tty, stream_get_tail(irp->input), Length))
    {
        irp->IoStatus = STATUS_UNSUCCESSFUL;
        Length = 0;

        DEBUG_WARN("write %s(%d) failed.", serial->path, tty->id);
    }
    else
    {
        DEBUG_SVC("write %llu-%llu to %s(%d).", Offset, Offset + Length, serial->path, tty->id);
    }

    stream_write_uint32(irp->output, Length);
    stream_write_uint8(irp->output, 0); /* Padding */

    irp->Complete(irp);
}
示例#8
0
static void parallel_process_irp_write(PARALLEL_DEVICE* parallel, IRP* irp)
{
    uint32 Length;
    uint64 Offset;
    ssize_t status;
    uint32 len;

    stream_read_uint32(irp->input, Length);
    stream_read_uint64(irp->input, Offset);
    stream_seek(irp->input, 20); /* Padding */

    DEBUG_SVC("Length %u Offset %llu", Length, Offset);

    len = Length;

    while (len > 0)
    {
        status = write(parallel->file, stream_get_tail(irp->input), len);

        if (status < 0)
        {
            irp->IoStatus = STATUS_UNSUCCESSFUL;
            Length = 0;

            DEBUG_WARN("write %s(%d) failed.", parallel->path, parallel->id);
            break;
        }

        stream_seek(irp->input, status);
        len -= status;
    }

    stream_write_uint32(irp->output, Length);
    stream_write_uint8(irp->output, 0); /* Padding */

    irp->Complete(irp);
}
示例#9
0
/* http://msdn.microsoft.com/en-us/library/dd407326.aspx */
static uint32 tsmf_codec_parse_VIDEOINFOHEADER2(TS_AM_MEDIA_TYPE* mediatype, STREAM* s)
{
	uint64 AvgTimePerFrame;

	/* VIDEOINFOHEADER2.rcSource, RECT(LONG left, LONG top, LONG right, LONG bottom) */
	stream_seek_uint32(s);
	stream_seek_uint32(s);
	stream_read_uint32(s, mediatype->Width);
	stream_read_uint32(s, mediatype->Height);
	/* VIDEOINFOHEADER2.rcTarget */
	stream_seek(s, 16);
	/* VIDEOINFOHEADER2.dwBitRate */
	stream_read_uint32(s, mediatype->BitRate);
	/* VIDEOINFOHEADER2.dwBitErrorRate */
	stream_seek_uint32(s);
	/* VIDEOINFOHEADER2.AvgTimePerFrame */
	stream_read_uint64(s, AvgTimePerFrame);
	mediatype->SamplesPerSecond.Numerator = 1000000;
	mediatype->SamplesPerSecond.Denominator = (int)(AvgTimePerFrame / 10LL);
	/* Remaining fields before bmiHeader */
	stream_seek(s, 24);

	return 72;
}
示例#10
0
文件: disk_file.c 项目: ydal/FreeRDP
boolean disk_file_set_information(DISK_FILE* file, uint32 FsInformationClass, uint32 Length, STREAM* input)
{
	char* s;
	mode_t m;
	uint64 size;
	char* fullpath;
	struct stat st;
	UNICONV* uniconv;
	struct timeval tv[2];
	uint64 LastWriteTime;
	uint32 FileAttributes;
	uint32 FileNameLength;

	switch (FsInformationClass)
	{
		case FileBasicInformation:
			/* http://msdn.microsoft.com/en-us/library/cc232094.aspx */
			stream_seek_uint64(input); /* CreationTime */
			stream_seek_uint64(input); /* LastAccessTime */
			stream_read_uint64(input, LastWriteTime);
			stream_seek_uint64(input); /* ChangeTime */
			stream_read_uint32(input, FileAttributes);

			if (fstat(file->fd, &st) != 0)
				return false;

			tv[0].tv_sec = st.st_atime;
			tv[0].tv_usec = 0;
			tv[1].tv_sec = (LastWriteTime > 0 ? FILE_TIME_RDP_TO_SYSTEM(LastWriteTime) : st.st_mtime);
			tv[1].tv_usec = 0;
			futimes(file->fd, tv);

			if (FileAttributes > 0)
			{
				m = st.st_mode;
				if ((FileAttributes & FILE_ATTRIBUTE_READONLY) == 0)
					m |= S_IWUSR;
				else
					m &= ~S_IWUSR;
				if (m != st.st_mode)
					fchmod(file->fd, st.st_mode);
			}
			break;

		case FileEndOfFileInformation:
			/* http://msdn.microsoft.com/en-us/library/cc232067.aspx */
		case FileAllocationInformation:
			/* http://msdn.microsoft.com/en-us/library/cc232076.aspx */
			stream_read_uint64(input, size);
			if (ftruncate(file->fd, size) != 0)
				return false;
			break;

		case FileDispositionInformation:
			/* http://msdn.microsoft.com/en-us/library/cc232098.aspx */
			stream_read_uint8(input, file->delete_pending);
			break;

		case FileRenameInformation:
			/* http://msdn.microsoft.com/en-us/library/cc232085.aspx */
			stream_seek_uint8(input); /* ReplaceIfExists */
			stream_seek_uint8(input); /* RootDirectory */
			stream_read_uint32(input, FileNameLength);
			uniconv = freerdp_uniconv_new();
			s = freerdp_uniconv_in(uniconv, stream_get_tail(input), FileNameLength);
			freerdp_uniconv_free(uniconv);

			fullpath = disk_file_combine_fullpath(file->basepath, s);
			xfree(s);

			if (rename(file->fullpath, fullpath) == 0)
			{
				DEBUG_SVC("renamed %s to %s", file->fullpath, fullpath);
				disk_file_set_fullpath(file, fullpath);
			}
			else
			{
				DEBUG_WARN("rename %s to %s failed", file->fullpath, fullpath);
				free(fullpath);
				return false;
			}

			break;

		default:
			DEBUG_WARN("invalid FsInformationClass %d", FsInformationClass);
			return false;
	}

	return true;
}