code
stringlengths 1
2.01M
| repo_name
stringlengths 3
62
| path
stringlengths 1
267
| language
stringclasses 231
values | license
stringclasses 13
values | size
int64 1
2.01M
|
|---|---|---|---|---|---|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class FieldDescriptor$TYPE_ENUM extends
FieldDescriptor {
public var enumType:Class
public function FieldDescriptor$TYPE_ENUM(
fullName:String, name:String, tag:uint, enumType:Class) {
this.fullName = fullName
this._name = name
this.tag = tag
this.enumType = enumType
}
override public function get type():Class {
return int
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_ENUM(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_ENUM(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/FieldDescriptor$TYPE_ENUM.as
|
ActionScript
|
bsd
| 1,031
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class FieldDescriptor$TYPE_SINT64 extends
FieldDescriptor {
public function FieldDescriptor$TYPE_SINT64(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get type():Class {
return Int64
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_SINT64(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_SINT64(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/FieldDescriptor$TYPE_SINT64.as
|
ActionScript
|
bsd
| 969
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class RepeatedFieldDescriptor$TYPE_BOOL extends
RepeatedFieldDescriptor {
public function RepeatedFieldDescriptor$TYPE_BOOL(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get nonPackedWireType():int {
return WireType.VARINT
}
override public function get type():Class {
return Array
}
override public function get elementType():Class {
return Boolean
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_BOOL(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_BOOL(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/RepeatedFieldDescriptor$TYPE_BOOL.as
|
ActionScript
|
bsd
| 1,147
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class FieldDescriptor$TYPE_SFIXED32 extends
FieldDescriptor {
public function FieldDescriptor$TYPE_SFIXED32(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get type():Class {
return int
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_SFIXED32(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_SFIXED32(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/FieldDescriptor$TYPE_SFIXED32.as
|
ActionScript
|
bsd
| 975
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class RepeatedFieldDescriptor$TYPE_SFIXED32 extends
RepeatedFieldDescriptor {
public function RepeatedFieldDescriptor$TYPE_SFIXED32(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get nonPackedWireType():int {
return WireType.FIXED_32_BIT
}
override public function get type():Class {
return Array
}
override public function get elementType():Class {
return int
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_SFIXED32(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_SFIXED32(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/RepeatedFieldDescriptor$TYPE_SFIXED32.as
|
ActionScript
|
bsd
| 1,165
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class RepeatedFieldDescriptor$TYPE_FIXED32 extends
RepeatedFieldDescriptor {
public function RepeatedFieldDescriptor$TYPE_FIXED32(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get nonPackedWireType():int {
return WireType.FIXED_32_BIT
}
override public function get type():Class {
return Array
}
override public function get elementType():Class {
return int
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_FIXED32(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_FIXED32(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/RepeatedFieldDescriptor$TYPE_FIXED32.as
|
ActionScript
|
bsd
| 1,161
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class FieldDescriptor$TYPE_SINT32 extends
FieldDescriptor {
public function FieldDescriptor$TYPE_SINT32(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get type():Class {
return int
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_SINT32(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_SINT32(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/FieldDescriptor$TYPE_SINT32.as
|
ActionScript
|
bsd
| 967
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class RepeatedFieldDescriptor$TYPE_UINT64 extends
RepeatedFieldDescriptor {
public function RepeatedFieldDescriptor$TYPE_UINT64(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get nonPackedWireType():int {
return WireType.VARINT
}
override public function get type():Class {
return Array
}
override public function get elementType():Class {
return UInt64
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_UINT64(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_UINT64(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/RepeatedFieldDescriptor$TYPE_UINT64.as
|
ActionScript
|
bsd
| 1,154
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class RepeatedFieldDescriptor$TYPE_SINT64 extends
RepeatedFieldDescriptor {
public function RepeatedFieldDescriptor$TYPE_SINT64(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get nonPackedWireType():int {
return WireType.VARINT
}
override public function get type():Class {
return Array
}
override public function get elementType():Class {
return Int64
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_SINT64(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_SINT64(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/RepeatedFieldDescriptor$TYPE_SINT64.as
|
ActionScript
|
bsd
| 1,153
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class FieldDescriptor$TYPE_FIXED32 extends
FieldDescriptor {
public function FieldDescriptor$TYPE_FIXED32(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get type():Class {
return int
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_FIXED32(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_FIXED32(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/FieldDescriptor$TYPE_FIXED32.as
|
ActionScript
|
bsd
| 971
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class RepeatedFieldDescriptor$TYPE_SINT32 extends
RepeatedFieldDescriptor {
public function RepeatedFieldDescriptor$TYPE_SINT32(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get nonPackedWireType():int {
return WireType.VARINT
}
override public function get type():Class {
return Array
}
override public function get elementType():Class {
return int
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_SINT32(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_SINT32(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/RepeatedFieldDescriptor$TYPE_SINT32.as
|
ActionScript
|
bsd
| 1,151
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class RepeatedFieldDescriptor$TYPE_INT64 extends
RepeatedFieldDescriptor {
public function RepeatedFieldDescriptor$TYPE_INT64(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get nonPackedWireType():int {
return WireType.VARINT
}
override public function get type():Class {
return Array
}
override public function get elementType():Class {
return Int64
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_INT64(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_INT64(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/RepeatedFieldDescriptor$TYPE_INT64.as
|
ActionScript
|
bsd
| 1,149
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class FieldDescriptor$TYPE_MESSAGE extends
FieldDescriptor {
public var messageUnion:Object
public function FieldDescriptor$TYPE_MESSAGE(
fullName:String, name:String, tag:uint, messageUnion:Object) {
this.fullName = fullName
this._name = name
this.tag = tag
this.messageUnion = messageUnion
}
override public function get type():Class {
return (messageUnion as Class) || Class(messageUnion = messageUnion())
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_MESSAGE(input, new type)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_MESSAGE(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/FieldDescriptor$TYPE_MESSAGE.as
|
ActionScript
|
bsd
| 1,131
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class RepeatedFieldDescriptor$TYPE_BYTES extends
RepeatedFieldDescriptor {
public function RepeatedFieldDescriptor$TYPE_BYTES(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get nonPackedWireType():int {
return WireType.LENGTH_DELIMITED
}
override public function get type():Class {
return Array
}
override public function get elementType():Class {
return flash.utils.ByteArray
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_BYTES(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_BYTES(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/RepeatedFieldDescriptor$TYPE_BYTES.as
|
ActionScript
|
bsd
| 1,175
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class FieldDescriptor$TYPE_INT64 extends
FieldDescriptor {
public function FieldDescriptor$TYPE_INT64(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get type():Class {
return Int64
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_INT64(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_INT64(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/FieldDescriptor$TYPE_INT64.as
|
ActionScript
|
bsd
| 965
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class FieldDescriptor$TYPE_UINT64 extends
FieldDescriptor {
public function FieldDescriptor$TYPE_UINT64(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get type():Class {
return UInt64
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_UINT64(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_UINT64(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/FieldDescriptor$TYPE_UINT64.as
|
ActionScript
|
bsd
| 970
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class FieldDescriptor$TYPE_FLOAT extends
FieldDescriptor {
public function FieldDescriptor$TYPE_FLOAT(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get type():Class {
return Number
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_FLOAT(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_FLOAT(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/FieldDescriptor$TYPE_FLOAT.as
|
ActionScript
|
bsd
| 966
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class RepeatedFieldDescriptor$TYPE_DOUBLE extends
RepeatedFieldDescriptor {
public function RepeatedFieldDescriptor$TYPE_DOUBLE(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get nonPackedWireType():int {
return WireType.FIXED_64_BIT
}
override public function get type():Class {
return Array
}
override public function get elementType():Class {
return Number
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_DOUBLE(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_DOUBLE(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/RepeatedFieldDescriptor$TYPE_DOUBLE.as
|
ActionScript
|
bsd
| 1,160
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class FieldDescriptor$TYPE_UINT32 extends
FieldDescriptor {
public function FieldDescriptor$TYPE_UINT32(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get type():Class {
return uint
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_UINT32(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_UINT32(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/FieldDescriptor$TYPE_UINT32.as
|
ActionScript
|
bsd
| 968
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class RepeatedFieldDescriptor$TYPE_MESSAGE extends
RepeatedFieldDescriptor {
public var messageUnion:Object
public function RepeatedFieldDescriptor$TYPE_MESSAGE(
fullName:String, name:String, tag:uint, messageUnion:Object) {
this.fullName = fullName
this._name = name
this.tag = tag
this.messageUnion = messageUnion
}
override public function get nonPackedWireType():int {
return WireType.LENGTH_DELIMITED
}
override public function get type():Class {
return Array
}
override public function get elementType():Class {
return (messageUnion as Class) || Class(messageUnion = messageUnion())
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_MESSAGE(input, new elementType)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_MESSAGE(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/RepeatedFieldDescriptor$TYPE_MESSAGE.as
|
ActionScript
|
bsd
| 1,332
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class FieldDescriptor$TYPE_DOUBLE extends
FieldDescriptor {
public function FieldDescriptor$TYPE_DOUBLE(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get type():Class {
return Number
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_DOUBLE(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_DOUBLE(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/FieldDescriptor$TYPE_DOUBLE.as
|
ActionScript
|
bsd
| 970
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class RepeatedFieldDescriptor$TYPE_UINT32 extends
RepeatedFieldDescriptor {
public function RepeatedFieldDescriptor$TYPE_UINT32(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get nonPackedWireType():int {
return WireType.VARINT
}
override public function get type():Class {
return Array
}
override public function get elementType():Class {
return uint
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_UINT32(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_UINT32(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/RepeatedFieldDescriptor$TYPE_UINT32.as
|
ActionScript
|
bsd
| 1,152
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class FieldDescriptor$TYPE_BYTES extends
FieldDescriptor {
public function FieldDescriptor$TYPE_BYTES(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get type():Class {
return flash.utils.ByteArray
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_BYTES(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_BYTES(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/FieldDescriptor$TYPE_BYTES.as
|
ActionScript
|
bsd
| 981
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class FieldDescriptor$TYPE_INT32 extends
FieldDescriptor {
public function FieldDescriptor$TYPE_INT32(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get type():Class {
return int
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_INT32(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_INT32(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/FieldDescriptor$TYPE_INT32.as
|
ActionScript
|
bsd
| 963
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class RepeatedFieldDescriptor$TYPE_STRING extends
RepeatedFieldDescriptor {
public function RepeatedFieldDescriptor$TYPE_STRING(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get nonPackedWireType():int {
return WireType.LENGTH_DELIMITED
}
override public function get type():Class {
return Array
}
override public function get elementType():Class {
return String
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_STRING(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_STRING(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/RepeatedFieldDescriptor$TYPE_STRING.as
|
ActionScript
|
bsd
| 1,164
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class FieldDescriptor$TYPE_BOOL extends
FieldDescriptor {
public function FieldDescriptor$TYPE_BOOL(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get type():Class {
return Boolean
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_BOOL(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_BOOL(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/FieldDescriptor$TYPE_BOOL.as
|
ActionScript
|
bsd
| 963
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class RepeatedFieldDescriptor$TYPE_SFIXED64 extends
RepeatedFieldDescriptor {
public function RepeatedFieldDescriptor$TYPE_SFIXED64(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get nonPackedWireType():int {
return WireType.FIXED_64_BIT
}
override public function get type():Class {
return Array
}
override public function get elementType():Class {
return Int64
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_SFIXED64(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_SFIXED64(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/RepeatedFieldDescriptor$TYPE_SFIXED64.as
|
ActionScript
|
bsd
| 1,167
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class RepeatedFieldDescriptor$TYPE_INT32 extends
RepeatedFieldDescriptor {
public function RepeatedFieldDescriptor$TYPE_INT32(
fullName:String, name:String, tag:uint) {
this.fullName = fullName
this._name = name
this.tag = tag
}
override public function get nonPackedWireType():int {
return WireType.VARINT
}
override public function get type():Class {
return Array
}
override public function get elementType():Class {
return int
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_INT32(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_INT32(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/RepeatedFieldDescriptor$TYPE_INT32.as
|
ActionScript
|
bsd
| 1,147
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf.fieldDescriptors {
import com.netease.protobuf.*
import flash.utils.*
/**
* @private
*/
public final class RepeatedFieldDescriptor$TYPE_ENUM extends
RepeatedFieldDescriptor {
public var enumType:Class
public function RepeatedFieldDescriptor$TYPE_ENUM(
fullName:String, name:String, tag:uint, enumType:Class) {
this.fullName = fullName
this._name = name
this.tag = tag
this.enumType = enumType
}
override public function get nonPackedWireType():int {
return WireType.VARINT
}
override public function get type():Class {
return Array
}
override public function get elementType():Class {
return int
}
override public function readSingleField(input:IDataInput):* {
return ReadUtils.read$TYPE_ENUM(input)
}
override public function writeSingleField(output:WritingBuffer,
value:*):void {
WriteUtils.write$TYPE_ENUM(output, value)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/fieldDescriptors/RepeatedFieldDescriptor$TYPE_ENUM.as
|
ActionScript
|
bsd
| 1,215
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2010 , NetEase.com,Inc. All rights reserved.
// Copyright (c) 2012 , Yang Bo. All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf {
import flash.errors.*
import flash.utils.*
/**
* @private
*/
public final class ReadUtils {
public static function skip(input:IDataInput, wireType:uint):void {
switch (wireType) {
case WireType.VARINT:
while (input.readUnsignedByte() >= 0x80) {}
break
case WireType.FIXED_64_BIT:
input.readInt()
input.readInt()
break
case WireType.LENGTH_DELIMITED:
for (var i:uint = read$TYPE_UINT32(input); i != 0; i--) {
input.readByte()
}
break
case WireType.FIXED_32_BIT:
input.readInt()
break
default:
throw new IOError("Invalid wire type: " + wireType)
}
}
public static function read$TYPE_DOUBLE(input:IDataInput):Number {
return input.readDouble()
}
public static function read$TYPE_FLOAT(input:IDataInput):Number {
return input.readFloat()
}
public static function read$TYPE_INT64(input:IDataInput):Int64 {
const result:Int64 = new Int64
var b:uint
var i:uint = 0
for (;; i += 7) {
b = input.readUnsignedByte()
if (i == 28) {
break
} else {
if (b >= 0x80) {
result.low |= ((b & 0x7f) << i)
} else {
result.low |= (b << i)
return result
}
}
}
if (b >= 0x80) {
b &= 0x7f
result.low |= (b << i)
result.high = b >>> 4
} else {
result.low |= (b << i)
result.high = b >>> 4
return result
}
for (i = 3;; i += 7) {
b = input.readUnsignedByte()
if (i < 32) {
if (b >= 0x80) {
result.high |= ((b & 0x7f) << i)
} else {
result.high |= (b << i)
break
}
}
}
return result
}
public static function read$TYPE_UINT64(input:IDataInput):UInt64 {
const result:UInt64 = new UInt64
var b:uint
var i:uint = 0
for (;; i += 7) {
b = input.readUnsignedByte()
if (i == 28) {
break
} else {
if (b >= 0x80) {
result.low |= ((b & 0x7f) << i)
} else {
result.low |= (b << i)
return result
}
}
}
if (b >= 0x80) {
b &= 0x7f
result.low |= (b << i)
result.high = b >>> 4
} else {
result.low |= (b << i)
result.high = b >>> 4
return result
}
for (i = 3;; i += 7) {
b = input.readUnsignedByte()
if (i < 32) {
if (b >= 0x80) {
result.high |= ((b & 0x7f) << i)
} else {
result.high |= (b << i)
break
}
}
}
return result
}
public static function read$TYPE_INT32(input:IDataInput):int {
return int(read$TYPE_UINT32(input))
}
public static function read$TYPE_FIXED64(input:IDataInput):UInt64 {
const result:UInt64 = new UInt64
result.low = input.readUnsignedInt()
result.high = input.readUnsignedInt()
return result
}
public static function read$TYPE_FIXED32(input:IDataInput):uint {
return input.readUnsignedInt()
}
public static function read$TYPE_BOOL(input:IDataInput):Boolean {
return read$TYPE_UINT32(input) != 0
}
public static function read$TYPE_STRING(input:IDataInput):String {
const length:uint = read$TYPE_UINT32(input)
return input.readUTFBytes(length)
}
public static function read$TYPE_BYTES(input:IDataInput):ByteArray {
const result:ByteArray = new ByteArray
const length:uint = read$TYPE_UINT32(input)
if (length > 0) {
input.readBytes(result, 0, length)
}
return result
}
public static function read$TYPE_UINT32(input:IDataInput):uint {
var result:uint = 0
for (var i:uint = 0;; i += 7) {
const b:uint = input.readUnsignedByte()
if (i < 32) {
if (b >= 0x80) {
result |= ((b & 0x7f) << i)
} else {
result |= (b << i)
break
}
} else {
while (input.readUnsignedByte() >= 0x80) {}
break
}
}
return result
}
public static function read$TYPE_ENUM(input:IDataInput):int {
return read$TYPE_INT32(input)
}
public static function read$TYPE_SFIXED32(input:IDataInput):int {
return input.readInt()
}
public static function read$TYPE_SFIXED64(input:IDataInput):Int64 {
const result:Int64 = new Int64
result.low = input.readUnsignedInt()
result.high = input.readInt()
return result
}
public static function read$TYPE_SINT32(input:IDataInput):int {
return ZigZag.decode32(read$TYPE_UINT32(input))
}
public static function read$TYPE_SINT64(input:IDataInput):Int64 {
const result:Int64 = read$TYPE_INT64(input)
const low:uint = result.low
const high:uint = result.high
result.low = ZigZag.decode64low(low, high)
result.high = ZigZag.decode64high(low, high)
return result
}
public static function read$TYPE_MESSAGE(input:IDataInput,
message:Message):Message {
const length:uint = read$TYPE_UINT32(input)
if (input.bytesAvailable < length) {
throw new IOError("Invalid message length: " + length)
}
const bytesAfterSlice:uint = input.bytesAvailable - length
message.used_by_generated_code::readFromSlice(input, bytesAfterSlice)
if (input.bytesAvailable != bytesAfterSlice) {
throw new IOError("Invalid nested message")
}
return message
}
public static function readPackedRepeated(input:IDataInput,
readFuntion:Function, value:Array):void {
const length:uint = read$TYPE_UINT32(input)
if (input.bytesAvailable < length) {
throw new IOError("Invalid message length: " + length)
}
const bytesAfterSlice:uint = input.bytesAvailable - length
while (input.bytesAvailable > bytesAfterSlice) {
value.push(readFuntion(input))
}
if (input.bytesAvailable != bytesAfterSlice) {
throw new IOError("Invalid packed repeated data")
}
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/ReadUtils.as
|
ActionScript
|
bsd
| 5,959
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf {
import flash.errors.IllegalOperationError
import flash.errors.IOError
import flash.utils.IDataInput
import flash.utils.ByteArray
/**
* @private
*/
public class RepeatedFieldDescriptor extends BaseFieldDescriptor {
public function get elementType():Class {
throw new IllegalOperationError("Not Implemented!")
}
public final function readNonPacked(input:IDataInput,
message:Message):void {
const destination:Array = message[name] || (message[name] = [])
destination.push(readSingleField(input))
}
public final function readPacked(input:IDataInput,
message:Message):void {
const destination:Array = message[name] || (message[name] = [])
const length:uint = ReadUtils.read$TYPE_UINT32(input)
if (input.bytesAvailable < length) {
throw new IOError("Invalid message length: " + length)
}
const bytesAfterSlice:uint = input.bytesAvailable - length
while (input.bytesAvailable > bytesAfterSlice) {
destination.push(readSingleField(input))
}
if (input.bytesAvailable != bytesAfterSlice) {
throw new IOError("Invalid packed destination data")
}
}
public function get nonPackedWireType():int {
throw new IllegalOperationError("Not Implemented!")
}
override public final function write(output:WritingBuffer,
message:Message):void {
const source:Array = message[name]
if ((tag & 7) == nonPackedWireType) {
for (var k:uint = 0; k < source.length; k++) {
WriteUtils.write$TYPE_UINT32(output, tag)
writeSingleField(output, source[k])
}
} else {
WriteUtils.write$TYPE_UINT32(output, tag)
const i:uint = output.beginBlock()
for (var j:uint = 0; j < source.length; j++) {
writeSingleField(output, source[j])
}
output.endBlock(i)
}
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/RepeatedFieldDescriptor.as
|
AngelScript
|
bsd
| 2,082
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2012 , Yang Bo. All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf {
/**
* @private
*/
public namespace used_by_generated_code
}
|
118194141-test
|
as3/com/netease/protobuf/used_by_generated_code.as
|
ActionScript
|
bsd
| 381
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2010 , NetEase.com,Inc. All rights reserved.
// Copyright (c) 2012 , Yang Bo. All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the New BSD License
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf {
import google.protobuf.MethodOptions
import google.protobuf.ServiceOptions
import flash.errors.*
import flash.utils.*
public final class CustomOption {
public static function getMethodOptions(methodFullName:String):MethodOptions {
const m:Array = methodFullName.match(/^(.+)\.[^\.]+$/)
if (m == null) {
return null
}
const serviceClass:Class = Class(getDefinitionByName(m[1]))
var optionsBytes:ByteArray
try {
optionsBytes =
serviceClass.OPTIONS_BYTES_BY_METHOD_NAME[methodFullName]
} catch (e:ReferenceError) {
return null
}
if (optionsBytes) {
const result:MethodOptions = new MethodOptions
result.mergeFrom(optionsBytes)
return result
} else {
return null
}
}
public static function getServiceOptions(serviceClass:Class):ServiceOptions {
var optionsBytes:ByteArray
try {
optionsBytes = serviceClass.OPTIONS_BYTES
} catch (e:ReferenceError) {
return null
}
const result:ServiceOptions = new ServiceOptions
result.mergeFrom(optionsBytes)
return result
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/CustomOption.as
|
ActionScript
|
bsd
| 1,445
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf {
import flash.errors.IllegalOperationError;
import flash.utils.IDataInput
/**
* @private
*/
public class FieldDescriptor extends BaseFieldDescriptor {
public final function read(input:IDataInput,
message:Message):void {
message[name] = readSingleField(input)
}
override public final function write(output:WritingBuffer,
message:Message):void {
WriteUtils.write$TYPE_UINT32(output, tag)
writeSingleField(output, message[name])
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/FieldDescriptor.as
|
ActionScript
|
bsd
| 779
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2010 , NetEase.com,Inc. All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf {
import flash.utils.ByteArray
/**
* @private
*/
public function stringToByteArray(s:String):ByteArray {
const ba:ByteArray = new ByteArray
ba.length = s.length
for (var i:uint = 0; i < s.length; ++i) {
ba[i] = s.charCodeAt(i)
}
return ba
}
}
|
118194141-test
|
as3/com/netease/protobuf/stringToByteArray.as
|
ActionScript
|
bsd
| 585
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2010 , NetEase.com,Inc. All rights reserved.
// Copyright (c) 2012 , Yang Bo. All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the New BSD License
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf {
import flash.errors.IllegalOperationError
import flash.errors.IOError
import flash.utils.IDataInput
import flash.utils.IDataOutput
use namespace com.netease.protobuf.used_by_generated_code
public class Message {
/**
* Parse data as a message of this type and merge it with this.
*
* @param input The source where data are reading from. <p>After calling
* this method, <code>input.endian</code> will be changed to <code>
* flash.utils.Endian.LITTLE_ENDIAN</code>. If <code>input</code> is a
* <code>flash.utils.ByteArray</code>, input.position will increase by
* number of bytes being read.</p>
*/
public final function mergeFrom(input:IDataInput):void {
input.endian = flash.utils.Endian.LITTLE_ENDIAN
used_by_generated_code::readFromSlice(input, 0)
}
/**
* Like <code>mergeFrom()</code>, but does not read until EOF. Instead,
* the size of the message (encoded as a varint) is read first, then
* the message data. Use <code>writeDelimitedTo()</code> to write
* messages in this format.
*
* @param input The source where data are reading from. <p>After calling
* this method, <code>input.endian</code> will be changed to <code>
* flash.utils.Endian.LITTLE_ENDIAN</code>. If <code>input</code> is a
* <code>flash.utils.ByteArray</code>, input.position will increase by
* number of bytes being read.</p>
*
* @see #mergeFrom()
* @see #writeDelimitedTo()
*/
public final function mergeDelimitedFrom(input:IDataInput):void {
input.endian = flash.utils.Endian.LITTLE_ENDIAN
ReadUtils.read$TYPE_MESSAGE(input, this)
}
/**
* Serializes the message and writes it to <code>output</code>.
*
* <p>
* NOTE: Protocol Buffers are not self-delimiting. Therefore, if you
* write any more data to the stream after the message, you must
* somehow ensure that the parser on the receiving end does not
* interpret this as being * part of the protocol message. This can be
* done e.g. by writing the size of the message before the data, then
* making sure to limit the input to that size on the receiving end
* (e.g. by wrapping the InputStream in one which limits the input).
* Alternatively, just use <code>writeDelimitedTo()</code>.
* </p>
*
* @param output The destination where data are writing to. <p>If <code>
* output</code> is a <code>flash.utils.ByteArray</code>, <code>
* output.position</code> will increase by number of bytes being
* written.</p>
*
* @see #writeDelimitedTo()
*/
public final function writeTo(output:IDataOutput):void {
const buffer:com.netease.protobuf.WritingBuffer = new com.netease.protobuf.WritingBuffer()
used_by_generated_code::writeToBuffer(buffer)
buffer.toNormal(output)
}
/**
* Like <code>writeTo()</code>, but writes the size of the message as
* a varint before writing the data. This allows more data to be
* written to the stream after the message without the need to delimit
* the message data yourself. Use <code>mergeDelimitedFrom()</code> to
* parse messages written by this method.
*
* @param output The destination where data are writing to. <p>If <code>
* output</code> is a <code>flash.utils.ByteArray</code>, <code>
* output.position</code> will increase by number of bytes being
* written.</p>
*
* @see #writeTo()
* @see #mergeDelimitedFrom()
*/
public final function writeDelimitedTo(output:IDataOutput):void {
const buffer:com.netease.protobuf.WritingBuffer = new com.netease.protobuf.WritingBuffer()
WriteUtils.write$TYPE_MESSAGE(buffer, this)
buffer.toNormal(output)
}
/**
* @private
*/
used_by_generated_code function readFromSlice(
input:IDataInput, bytesAfterSlice:uint):void {
throw new IllegalOperationError("Not implemented!")
}
/**
* @private
*/
used_by_generated_code function writeToBuffer(
output:WritingBuffer):void {
throw new IllegalOperationError("Not implemented!")
}
private function writeSingleUnknown(output:WritingBuffer, tag:uint,
value:*):void {
WriteUtils.write$TYPE_UINT32(output, tag)
switch (tag & 7) {
case WireType.VARINT:
WriteUtils.write$TYPE_UINT64(output, value)
break
case WireType.FIXED_64_BIT:
WriteUtils.write$TYPE_FIXED64(output, value)
break
case WireType.LENGTH_DELIMITED:
WriteUtils.write$TYPE_BYTES(output, value)
break
case WireType.FIXED_32_BIT:
WriteUtils.write$TYPE_FIXED32(output, value)
break
default:
throw new IOError("Invalid wire type: " + (tag & 7))
}
}
/**
* @private
*/
protected final function writeUnknown(output:WritingBuffer,
fieldName:String):void {
const tag:uint = uint(fieldName)
if (tag == 0) {
throw new ArgumentError(
"Attemp to write an undefined string filed: " +
fieldName)
}
WriteUtils.writeUnknownPair(output, tag, this[fieldName])
}
/**
* @private
*/
protected final function writeExtensionOrUnknown(output:WritingBuffer,
fieldName:String):void {
var fieldDescriptor:BaseFieldDescriptor
try {
fieldDescriptor =
BaseFieldDescriptor.getExtensionByName(fieldName)
} catch (e:ReferenceError) {
writeUnknown(output, fieldName)
return
}
fieldDescriptor.write(output, this)
}
/**
* @private
*/
protected final function readUnknown(input:IDataInput, tag:uint):void {
var value:*
switch (tag & 7) {
case WireType.VARINT:
value = ReadUtils.read$TYPE_UINT64(input)
break
case WireType.FIXED_64_BIT:
value = ReadUtils.read$TYPE_FIXED64(input)
break
case WireType.LENGTH_DELIMITED:
value = ReadUtils.read$TYPE_BYTES(input)
break
case WireType.FIXED_32_BIT:
value = ReadUtils.read$TYPE_FIXED32(input)
break
default:
throw new IOError("Invalid wire type: " + (tag & 7))
}
const currentValue:* = this[tag]
if (!currentValue) {
this[tag] = value
} else if (currentValue is Array) {
currentValue.push(value)
} else {
this[tag] = [currentValue, value]
}
}
/**
* @private
*/
protected final function readExtensionOrUnknown(extensions:Array,
input:IDataInput, tag:uint):void {
var readFunction:Function = extensions[tag];
if (readFunction != null) {
readFunction(input, this);
} else {
readUnknown(input, tag)
}
}
public final function toString():String {
return TextFormat.printToString(this)
}
/**
* Get information of a field.
*/
public static function getExtensionByName(
name:String):IFieldDescriptor {
return BaseFieldDescriptor.getExtensionByName(name)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/Message.as
|
ActionScript
|
bsd
| 7,031
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo. All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the New BSD License
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf {
/**
* Run-time infomation for a field.
*/
public interface IFieldDescriptor {
function get type():Class
function get name():String
function get tagNumber():uint
}
}
|
118194141-test
|
as3/com/netease/protobuf/IFieldDescriptor.as
|
ActionScript
|
bsd
| 493
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2010 , NetEase.com,Inc. All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf {
import flash.errors.*;
import flash.utils.*;
/**
* @private
*/
public final class WritingBuffer extends ByteArray {
public function WritingBuffer() {
endian = Endian.LITTLE_ENDIAN
}
/*
// for Flash Player 9
[ArrayElementType("uint")]
private const slices:Array = []
/*/
// for Flash Player 10
private const slices:Vector.<uint> = new Vector.<uint>
//*/
public function beginBlock():uint {
slices.push(position)
const beginSliceIndex:uint = slices.length
slices.length += 2
slices.push(position)
return beginSliceIndex
}
public function endBlock(beginSliceIndex:uint):void {
slices.push(position)
const beginPosition:uint = slices[beginSliceIndex + 2]
slices[beginSliceIndex] = position
WriteUtils.write$TYPE_UINT32(this, position - beginPosition)
slices[beginSliceIndex + 1] = position
slices.push(position)
}
public function toNormal(output:IDataOutput):void {
var i:uint = 0
var begin:uint = 0
while (i < slices.length) {
var end:uint = slices[i]
++i
if (end > begin) {
output.writeBytes(this, begin, end - begin)
} else if (end < begin) {
throw new IllegalOperationError
}
begin = slices[i]
++i
}
output.writeBytes(this, begin)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/WritingBuffer.as
|
AngelScript
|
bsd
| 1,595
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2010 , NetEase.com,Inc. All rights reserved.
// Copyright (c) 2012 , Yang Bo. All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf {
import flash.errors.*
import flash.utils.*
/**
* @private
*/
public final class WriteUtils {
private static function writeSingleUnknown(output:WritingBuffer,
tag:uint, value:*):void {
WriteUtils.write$TYPE_UINT32(output, tag)
switch (tag & 7) {
case WireType.VARINT:
WriteUtils.write$TYPE_UINT64(output, value)
break
case WireType.FIXED_64_BIT:
WriteUtils.write$TYPE_FIXED64(output, value)
break
case WireType.LENGTH_DELIMITED:
WriteUtils.write$TYPE_BYTES(output, value)
break
case WireType.FIXED_32_BIT:
WriteUtils.write$TYPE_FIXED32(output, value)
break
default:
throw new IOError("Invalid wire type: " + (tag & 7))
}
}
public static function writeUnknownPair(output:WritingBuffer, tag:uint,
value:*):void {
const repeated:Array = value as Array
if (repeated) {
for each (var element:* in repeated) {
writeSingleUnknown(output, tag, element)
}
} else {
writeSingleUnknown(output, tag, value)
}
}
private static function writeVarint64(output:WritingBuffer,
low:uint, high:uint):void {
if (high == 0) {
write$TYPE_UINT32(output, low)
} else {
for (var i:uint = 0; i < 4; ++i) {
output.writeByte((low & 0x7F) | 0x80)
low >>>= 7
}
if ((high & (0xFFFFFFF << 3)) == 0) {
output.writeByte((high << 4) | low)
} else {
output.writeByte((((high << 4) | low) & 0x7F) | 0x80)
write$TYPE_UINT32(output, high >>> 3)
}
}
}
public static function writeTag(output:WritingBuffer,
wireType:uint, number:uint):void {
write$TYPE_UINT32(output, (number << 3) | wireType)
}
public static function write$TYPE_DOUBLE(output:WritingBuffer, value:Number):void {
output.writeDouble(value)
}
public static function write$TYPE_FLOAT(output:WritingBuffer, value:Number):void {
output.writeFloat(value)
}
public static function write$TYPE_INT64(output:WritingBuffer, value:Int64):void {
writeVarint64(output, value.low, value.high)
}
public static function write$TYPE_UINT64(output:WritingBuffer, value:UInt64):void {
writeVarint64(output, value.low, value.high)
}
public static function write$TYPE_INT32(output:WritingBuffer, value:int):void {
if (value < 0) {
writeVarint64(output, value, 0xFFFFFFFF)
} else {
write$TYPE_UINT32(output, value)
}
}
public static function write$TYPE_FIXED64(output:WritingBuffer, value:UInt64):void {
output.writeUnsignedInt(value.low)
output.writeUnsignedInt(value.high)
}
public static function write$TYPE_FIXED32(output:WritingBuffer, value:uint):void {
output.writeUnsignedInt(value)
}
public static function write$TYPE_BOOL(output:WritingBuffer, value:Boolean):void {
output.writeByte(value ? 1 : 0)
}
public static function write$TYPE_STRING(output:WritingBuffer, value:String):void {
const i:uint = output.beginBlock()
output.writeUTFBytes(value)
output.endBlock(i)
}
public static function write$TYPE_BYTES(output:WritingBuffer, value:ByteArray):void {
write$TYPE_UINT32(output, value.length)
output.writeBytes(value)
}
public static function write$TYPE_UINT32(output:WritingBuffer, value:uint):void {
for (;;) {
if (value < 0x80) {
output.writeByte(value)
return;
} else {
output.writeByte((value & 0x7F) | 0x80)
value >>>= 7
}
}
}
public static function write$TYPE_ENUM(output:WritingBuffer, value:int):void {
write$TYPE_INT32(output, value)
}
public static function write$TYPE_SFIXED32(output:WritingBuffer, value:int):void {
output.writeInt(value)
}
public static function write$TYPE_SFIXED64(output:WritingBuffer, value:Int64):void {
output.writeUnsignedInt(value.low)
output.writeInt(value.high)
}
public static function write$TYPE_SINT32(output:WritingBuffer, value:int):void {
write$TYPE_UINT32(output, ZigZag.encode32(value))
}
public static function write$TYPE_SINT64(output:WritingBuffer, value:Int64):void {
writeVarint64(output,
ZigZag.encode64low(value.low, value.high),
ZigZag.encode64high(value.low, value.high))
}
public static function write$TYPE_MESSAGE(output:WritingBuffer, value:Message):void {
const i:uint = output.beginBlock()
value.used_by_generated_code::writeToBuffer(output)
output.endBlock(i)
}
public static function writePackedRepeated(output:WritingBuffer,
writeFunction:Function, value:Array):void {
const i:uint = output.beginBlock()
for (var j:uint = 0; j < value.length; j++) {
writeFunction(output, value[j])
}
output.endBlock(i)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/WriteUtils.as
|
ActionScript
|
bsd
| 4,977
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2010 , NetEase.com,Inc. All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf {
/**
* @private
*/
public final class ZigZag {
public static function encode32(n:int):int {
return (n << 1) ^ (n >> 31)
}
public static function decode32(n:int):int {
return (n >>> 1) ^ -(n & 1)
}
public static function encode64low(low:uint, high:int):uint {
return (low << 1) ^ (high >> 31)
}
public static function encode64high(low:uint, high:int):int {
return (low >>> 31) ^ (high << 1) ^ (high >> 31)
}
public static function decode64low(low:uint, high:int):uint {
return (high << 31) ^ (low >>> 1) ^ -(low & 1)
}
public static function decode64high(low:uint, high:int):int {
return (high >>> 1) ^ -(low & 1)
}
}
}
|
118194141-test
|
as3/com/netease/protobuf/ZigZag.as
|
AngelScript
|
bsd
| 990
|
// vim: tabstop=4 shiftwidth=4
// Copyright (c) 2011 , Yang Bo All rights reserved.
//
// Author: Yang Bo (pop.atry@gmail.com)
//
// Use, modification and distribution are subject to the "New BSD License"
// as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
package com.netease.protobuf {
import flash.errors.IllegalOperationError
import flash.utils.getDefinitionByName;
import flash.utils.IDataInput
/**
* @private
*/
public class BaseFieldDescriptor implements IFieldDescriptor {
public var fullName:String
protected var _name:String
public final function get name():String {
return _name
}
protected var tag:uint
public final function get tagNumber():uint {
return tag >>> 3
}
public function get type():Class {
throw new IllegalOperationError("Not Implemented!")
}
public function readSingleField(input:IDataInput):* {
throw new IllegalOperationError("Not Implemented!")
}
public function writeSingleField(output:WritingBuffer, value:*):void {
throw new IllegalOperationError("Not Implemented!")
}
public function write(destination:WritingBuffer, source:Message):void {
throw new IllegalOperationError("Not Implemented!")
}
private static const ACTIONSCRIPT_KEYWORDS:Object = {
"as" : true, "break" : true, "case" : true,
"catch" : true, "class" : true, "const" : true,
"continue" : true, "default" : true, "delete" : true,
"do" : true, "else" : true, "extends" : true,
"false" : true, "finally" : true, "for" : true,
"function" : true, "if" : true, "implements" : true,
"import" : true, "in" : true, "instanceof" : true,
"interface" : true, "internal" : true, "is" : true,
"native" : true, "new" : true, "null" : true,
"package" : true, "private" : true, "protected" : true,
"public" : true, "return" : true, "super" : true,
"switch" : true, "this" : true, "throw" : true,
"to" : true, "true" : true, "try" : true,
"typeof" : true, "use" : true, "var" : true,
"void" : true, "while" : true, "with" : true
}
public function toString():String {
return name
}
internal static function getExtensionByName(
name:String):BaseFieldDescriptor {
const fieldPosition:int = name.lastIndexOf('/')
if (fieldPosition == -1) {
return BaseFieldDescriptor(getDefinitionByName(name))
} else {
return getDefinitionByName(name.substring(0, fieldPosition))[
name.substring(fieldPosition + 1)]
}
}
}
}
function regexToUpperCase(matched:String, index:int, whole:String):String {
return matched.charAt(1).toUpperCase()
}
|
118194141-test
|
as3/com/netease/protobuf/BaseFieldDescriptor.as
|
ActionScript
|
bsd
| 2,596
|
#ifndef __NONAME_GETPROC_H__
#define __NONAME_GETPROC_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#include "nm_mem.h"
#include "nm_undoc.h"
class kgetproc {
public:
kgetproc(PDRIVER_OBJECT DriverObj) {m_LoadedModuleList = (PLIST_ENTRY)DriverObj->DriverSection;}
PVOID GetSystemRoutineAddress(PUNICODE_STRING ModuleName, PUNICODE_STRING SystemRoutineName);
private:
PVOID FindExportedRoutineByName(PVOID DllBase, PANSI_STRING AnsiImageRoutineName);
PLIST_ENTRY m_LoadedModuleList;
};
#endif
|
0cch
|
branches/noname/0.0.1.1/nm_getproc.h
|
C++
|
lgpl
| 526
|
#ifndef __NM_EXCEPTION_H__
#define __NM_EXCEPTION_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#include "nm_mem.h"
class KException
{
public:
static void Install();
NTSTATUS Status() const;
PVOID const At() const;
protected:
KException(EXCEPTION_POINTERS const &info);
static void __cdecl Translator(ULONG Code, EXCEPTION_POINTERS *info);
PVOID m_IP;
NTSTATUS m_Status;
};
class KExceptionAccessViolation : public KException
{
public:
PVOID const Address() const;
bool IsWrite() const;
protected:
friend KException;
KExceptionAccessViolation(EXCEPTION_POINTERS const &info);
PVOID m_Addr;
bool m_IsWrite;
};
inline
NTSTATUS KException::Status() const
{
return m_Status;
}
inline
PVOID const KException::At() const
{
return m_IP;
}
inline
PVOID const KExceptionAccessViolation::Address() const
{
return m_Addr;
}
inline
bool KExceptionAccessViolation::IsWrite() const
{
return m_IsWrite;
}
#endif
|
0cch
|
branches/noname/0.0.1.1/nm_exception.h
|
C++
|
lgpl
| 1,003
|
#include "nm_hashtable.h"
|
0cch
|
branches/noname/0.0.1.1/nm_hashtable.cpp
|
C++
|
lgpl
| 29
|
#include "nm_mem.h"
klookaside::klookaside( ULONG Size, ULONG Tag /*= NM_LOOKASIDE_TAG*/, POOL_TYPE PoolType /*= PagedPool*/ )
: m_PagedLookasideList(NULL), m_NPagedLookasideList(NULL), m_PoolType(PoolType);
{
if (PoolType == NonPagedPool) {
m_NPagedLookasideList = new(NonPagedPool, Tag) NPAGED_LOOKASIDE_LIST;
ExInitializeNPagedLookasideList(m_NPagedLookasideList,
NULL,
NULL,
0,
Size,
Tag,
0);
}
else {
m_PagedLookasideList = new(NonPagedPool, Tag) PAGED_LOOKASIDE_LIST;
ExInitializePagedLookasideList(m_PagedLookasideList,
NULL,
NULL,
0,
Size,
Tag,
0);
}
}
void klookaside::Release()
{
if (m_PagedLookasideList != NULL) {
ExDeletePagedLookasideList(m_PagedLookasideList);
delete m_PagedLookasideList;
m_PagedLookasideList = NULL;
}
if (m_NPagedLookasideList != NULL) {
ExDeleteNPagedLookasideList(m_NPagedLookasideList);
delete m_NPagedLookasideList;
m_NPagedLookasideList = NULL;
}
}
PVOID klookaside::Allocate()
{
PVOID Buffer = NULL;
if (m_PoolType == PagedPool) {
Buffer = ExAllocateFromPagedLookasideList(m_PagedLookasideList);
}
else if (m_PoolType == NonPagedPool) {
Buffer = ExAllocateFromNPagedLookasideList(m_NPagedLookasideList);
}
return Buffer;
}
VOID klookaside::Free( PVOID Buffer )
{
if (Buffer == NULL) {
return;
}
if (m_PoolType == PagedPool) {
ExFreeToPagedLookasideList(m_PagedLookasideList, Buffer);
}
else if (m_PoolType == NonPagedPool) {
ExFreeToNPagedLookasideList(m_NPagedLookasideList, Buffer);
}
}
|
0cch
|
branches/noname/0.0.1.1/nm_mem.cpp
|
C++
|
lgpl
| 1,629
|
#include "nm_workthread.h"
kworkthread::kworkthread() : m_Stop(FALSE), m_Lookaside(sizeof(WORK_ITEM))
{
RtlZeroMemory(&m_ClientId, sizeof(CLIENT_ID));
InitializeListHead(&m_ListHeader);
KeInitializeEvent(&m_InsertEvent, SynchronizationEvent, FALSE);
KeInitializeSpinLock(&m_Lock);
PsCreateSystemThread(&m_ThreadHandle, THREAD_ALL_ACCESS, NULL, NULL, &m_ClientId, Run, this);
}
void kworkthread::Release()
{
m_Stop = TRUE;
KeSetEvent(&m_InsertEvent, 0, FALSE);
KeWaitForSingleObject(m_ThreadHandle, Executive, KernelMode, FALSE, NULL);
ZwClose(m_ThreadHandle);
}
void kworkthread::Run(PVOID Context)
{
kworkthread *pthis = (kworkthread *)Context;
LARGE_INTEGER timeout;
PWORK_ITEM WorkItem;
NTSTATUS ns;
timeout.QuadPart = -10000 * 10 * 1000;
while (TRUE)
{
ns = KeWaitForSingleObject((PVOID)&pthis->m_InsertEvent, Executive, KernelMode, FALSE, &timeout);
if (ns == STATUS_TIMEOUT) {
KdPrint(("kworkthread timeout\n"));
}
if (pthis->m_Stop) {
break;
}
while ((WorkItem =
CONTAINING_RECORD(
ExInterlockedRemoveHeadList(&pthis->m_ListHeader, &pthis->m_Lock),
WORK_ITEM,
Next )) != NULL)
{
if (WorkItem->StartAddress != NULL) {
WorkItem->StartAddress(WorkItem->Context);
}
KeSetEvent( &WorkItem->Event, 0, FALSE );
pthis->m_Lookaside.Free(WorkItem);
}
if (pthis->m_Stop) {
break;
}
}
}
void kworkthread::InsertItem(WORKITEMPROC Address, PVOID Context, PRKEVENT *Event)
{
PWORK_ITEM WorkItem;
if (!MmIsAddressValid(Address)) {
return;
}
WorkItem = (PWORK_ITEM)m_Lookaside.Allocate();
if (WorkItem == NULL) return;
WorkItem->Next.Flink = NULL;
WorkItem->Next.Blink = NULL;
WorkItem->StartAddress = Address;
WorkItem->Context = Context;
if (Event != NULL) {
*Event = &WorkItem->Event;
}
KeInitializeEvent(&WorkItem->Event, SynchronizationEvent, FALSE);
ExInterlockedInsertTailList(&m_ListHeader, &WorkItem->Next, &m_Lock);
KeSetEvent(&m_InsertEvent, 0, FALSE);
}
|
0cch
|
branches/noname/0.0.1.1/nm_workthread.cpp
|
C++
|
lgpl
| 2,049
|
#ifndef __NONAME_CRICULARQUEUE_H__
#define __NONAME_CRICULARQUEUE_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#include "nm_mem.h"
#define DEFAULT_MAX_CQ_SIZE 64
template <class T>
class cirbuf
{
public:
cirbuf( ULONG Size = DEFAULT_MAX_CQ_SIZE ) : m_Tail(0), m_Head(0), m_ItemCount(0)
{
m_Buffer = new T[Size];
m_MaxSize = Size;
}
void Release()
{
delete[] m_Buffer;
m_MaxSize = 0;
}
public:
void Push( T &val ) {
m_Buffer[m_Tail] = val;
if ((m_Tail == m_Head) && (m_ItemCount != 0)) {
m_Head = ( (m_Head + 1) % m_MaxSize );
}
m_Tail = ( (m_Tail + 1) % m_MaxSize );
if (m_ItemCount != m_MaxSize) m_ItemCount++;
}
void Pop( T &val ) {
val = m_Buffer[m_Head];
m_Head = ( (m_Head + 1) % m_MaxSize );
m_ItemCount--;
}
bool IsEmpty() { return (m_ItemCount == 0); }
ULONG GetCurSize() { return m_ItemCount; }
private:
ULONG m_Head;
ULONG m_Tail;
ULONG m_ItemCount;
ULONG m_MaxSize;
T *m_Buffer;
};
#endif
|
0cch
|
branches/noname/0.0.1.1/nm_crique.h
|
C++
|
lgpl
| 1,011
|
#include "nm_list.h"
|
0cch
|
branches/noname/0.0.1.1/nm_list.cpp
|
C++
|
lgpl
| 24
|
#include "nm_exception.h"
extern "C" {
typedef void (__cdecl *_se_translator_function)(ULONG ExceptionCode, EXCEPTION_POINTERS* pExceptionPointers);
_se_translator_function __cdecl set_se_translator(_se_translator_function);
}
KException::KException(EXCEPTION_POINTERS const &info)
{
EXCEPTION_RECORD const &exception = *(info.ExceptionRecord);
m_IP = exception.ExceptionAddress;
m_Status = exception.ExceptionCode;
}
void KException::Install()
{
set_se_translator(Translator);
}
KExceptionAccessViolation::KExceptionAccessViolation(EXCEPTION_POINTERS const &info) :
KException(info)
{
EXCEPTION_RECORD const &exception = *(info.ExceptionRecord);
m_Addr = (PVOID) exception.ExceptionInformation[1];
m_IsWrite = (exception.ExceptionInformation[0]==1);
}
void __cdecl KException::Translator(ULONG Code, EXCEPTION_POINTERS *info)
{
if (Code != STATUS_ACCESS_VIOLATION) {
throw KException(*info);
}
else {
throw KExceptionAccessViolation(*info);
}
}
|
0cch
|
branches/noname/0.0.1.1/nm_exception.cpp
|
C++
|
lgpl
| 1,033
|
/*
---------------------------------------------------------------------------
Copyright (c) 2003, Dominik Reichl <dominik.reichl@t-online.de>, Germany.
All rights reserved.
Distributed under the terms of the GNU General Public License v2.
This software is provided 'as is' with no explicit or implied warranties
in respect of its properties, including, but not limited to, correctness
and/or fitness for purpose.
---------------------------------------------------------------------------
*/
#include "crc32.h"
// CRC-32 polynominal:
// X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X+1
static unsigned long crc32tab[] = {
0x00000000L, 0x77073096L, 0xEE0E612CL, 0x990951BAL,
0x076DC419L, 0x706AF48FL, 0xE963A535L, 0x9E6495A3L,
0x0EDB8832L, 0x79DCB8A4L, 0xE0D5E91EL, 0x97D2D988L,
0x09B64C2BL, 0x7EB17CBDL, 0xE7B82D07L, 0x90BF1D91L,
0x1DB71064L, 0x6AB020F2L, 0xF3B97148L, 0x84BE41DEL,
0x1ADAD47DL, 0x6DDDE4EBL, 0xF4D4B551L, 0x83D385C7L,
0x136C9856L, 0x646BA8C0L, 0xFD62F97AL, 0x8A65C9ECL,
0x14015C4FL, 0x63066CD9L, 0xFA0F3D63L, 0x8D080DF5L,
0x3B6E20C8L, 0x4C69105EL, 0xD56041E4L, 0xA2677172L,
0x3C03E4D1L, 0x4B04D447L, 0xD20D85FDL, 0xA50AB56BL,
0x35B5A8FAL, 0x42B2986CL, 0xDBBBC9D6L, 0xACBCF940L,
0x32D86CE3L, 0x45DF5C75L, 0xDCD60DCFL, 0xABD13D59L,
0x26D930ACL, 0x51DE003AL, 0xC8D75180L, 0xBFD06116L,
0x21B4F4B5L, 0x56B3C423L, 0xCFBA9599L, 0xB8BDA50FL,
0x2802B89EL, 0x5F058808L, 0xC60CD9B2L, 0xB10BE924L,
0x2F6F7C87L, 0x58684C11L, 0xC1611DABL, 0xB6662D3DL,
0x76DC4190L, 0x01DB7106L, 0x98D220BCL, 0xEFD5102AL,
0x71B18589L, 0x06B6B51FL, 0x9FBFE4A5L, 0xE8B8D433L,
0x7807C9A2L, 0x0F00F934L, 0x9609A88EL, 0xE10E9818L,
0x7F6A0DBBL, 0x086D3D2DL, 0x91646C97L, 0xE6635C01L,
0x6B6B51F4L, 0x1C6C6162L, 0x856530D8L, 0xF262004EL,
0x6C0695EDL, 0x1B01A57BL, 0x8208F4C1L, 0xF50FC457L,
0x65B0D9C6L, 0x12B7E950L, 0x8BBEB8EAL, 0xFCB9887CL,
0x62DD1DDFL, 0x15DA2D49L, 0x8CD37CF3L, 0xFBD44C65L,
0x4DB26158L, 0x3AB551CEL, 0xA3BC0074L, 0xD4BB30E2L,
0x4ADFA541L, 0x3DD895D7L, 0xA4D1C46DL, 0xD3D6F4FBL,
0x4369E96AL, 0x346ED9FCL, 0xAD678846L, 0xDA60B8D0L,
0x44042D73L, 0x33031DE5L, 0xAA0A4C5FL, 0xDD0D7CC9L,
0x5005713CL, 0x270241AAL, 0xBE0B1010L, 0xC90C2086L,
0x5768B525L, 0x206F85B3L, 0xB966D409L, 0xCE61E49FL,
0x5EDEF90EL, 0x29D9C998L, 0xB0D09822L, 0xC7D7A8B4L,
0x59B33D17L, 0x2EB40D81L, 0xB7BD5C3BL, 0xC0BA6CADL,
0xEDB88320L, 0x9ABFB3B6L, 0x03B6E20CL, 0x74B1D29AL,
0xEAD54739L, 0x9DD277AFL, 0x04DB2615L, 0x73DC1683L,
0xE3630B12L, 0x94643B84L, 0x0D6D6A3EL, 0x7A6A5AA8L,
0xE40ECF0BL, 0x9309FF9DL, 0x0A00AE27L, 0x7D079EB1L,
0xF00F9344L, 0x8708A3D2L, 0x1E01F268L, 0x6906C2FEL,
0xF762575DL, 0x806567CBL, 0x196C3671L, 0x6E6B06E7L,
0xFED41B76L, 0x89D32BE0L, 0x10DA7A5AL, 0x67DD4ACCL,
0xF9B9DF6FL, 0x8EBEEFF9L, 0x17B7BE43L, 0x60B08ED5L,
0xD6D6A3E8L, 0xA1D1937EL, 0x38D8C2C4L, 0x4FDFF252L,
0xD1BB67F1L, 0xA6BC5767L, 0x3FB506DDL, 0x48B2364BL,
0xD80D2BDAL, 0xAF0A1B4CL, 0x36034AF6L, 0x41047A60L,
0xDF60EFC3L, 0xA867DF55L, 0x316E8EEFL, 0x4669BE79L,
0xCB61B38CL, 0xBC66831AL, 0x256FD2A0L, 0x5268E236L,
0xCC0C7795L, 0xBB0B4703L, 0x220216B9L, 0x5505262FL,
0xC5BA3BBEL, 0xB2BD0B28L, 0x2BB45A92L, 0x5CB36A04L,
0xC2D7FFA7L, 0xB5D0CF31L, 0x2CD99E8BL, 0x5BDEAE1DL,
0x9B64C2B0L, 0xEC63F226L, 0x756AA39CL, 0x026D930AL,
0x9C0906A9L, 0xEB0E363FL, 0x72076785L, 0x05005713L,
0x95BF4A82L, 0xE2B87A14L, 0x7BB12BAEL, 0x0CB61B38L,
0x92D28E9BL, 0xE5D5BE0DL, 0x7CDCEFB7L, 0x0BDBDF21L,
0x86D3D2D4L, 0xF1D4E242L, 0x68DDB3F8L, 0x1FDA836EL,
0x81BE16CDL, 0xF6B9265BL, 0x6FB077E1L, 0x18B74777L,
0x88085AE6L, 0xFF0F6A70L, 0x66063BCAL, 0x11010B5CL,
0x8F659EFFL, 0xF862AE69L, 0x616BFFD3L, 0x166CCF45L,
0xA00AE278L, 0xD70DD2EEL, 0x4E048354L, 0x3903B3C2L,
0xA7672661L, 0xD06016F7L, 0x4969474DL, 0x3E6E77DBL,
0xAED16A4AL, 0xD9D65ADCL, 0x40DF0B66L, 0x37D83BF0L,
0xA9BCAE53L, 0xDEBB9EC5L, 0x47B2CF7FL, 0x30B5FFE9L,
0xBDBDF21CL, 0xCABAC28AL, 0x53B39330L, 0x24B4A3A6L,
0xBAD03605L, 0xCDD70693L, 0x54DE5729L, 0x23D967BFL,
0xB3667A2EL, 0xC4614AB8L, 0x5D681B02L, 0x2A6F2B94L,
0xB40BBE37L, 0xC30C8EA1L, 0x5A05DF1BL, 0x2D02EF8DL
};
void crc32Init(unsigned long *pCrc32)
{
*pCrc32 = 0xFFFFFFFF;
}
void crc32Update(unsigned long *pCrc32, unsigned char *pData, unsigned long uSize)
{
unsigned long i = 0;
for(i = 0; i < uSize; i++)
*pCrc32 = ((*pCrc32) >> 8) ^ crc32tab[(pData[i]) ^ ((*pCrc32) & 0x000000FF)];
}
// Make the final adjustment
void crc32Finish(unsigned long *pCrc32)
{
*pCrc32 = ~(*pCrc32);
}
|
0cch
|
branches/noname/0.0.1.1/algo/crc32.cpp
|
C++
|
lgpl
| 4,531
|
/*
---------------------------------------------------------------------------
Copyright (c) 2003, Dominik Reichl <dominik.reichl@t-online.de>, Germany.
All rights reserved.
Distributed under the terms of the GNU General Public License v2.
This software is provided 'as is' with no explicit or implied warranties
in respect of its properties, including, but not limited to, correctness
and/or fitness for purpose.
---------------------------------------------------------------------------
*/
#ifndef ___CRC32_H___
#define ___CRC32_H___
void crc32Init(unsigned long *pCrc32);
void crc32Update(unsigned long *pCrc32, unsigned char *pData, unsigned long uSize);
void crc32Finish(unsigned long *pCrc32);
#endif /* ___CRC32_H___ */
|
0cch
|
branches/noname/0.0.1.1/algo/crc32.h
|
C
|
lgpl
| 763
|
#include "nm_stack.h"
|
0cch
|
branches/noname/0.0.1.1/nm_stack.cpp
|
C++
|
lgpl
| 25
|
#ifndef __NONAME_LIST_H__
#define __NONAME_LIST_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#include "nm_mem.h"
typedef BOOLEAN (__stdcall *COMPAREPROC)(PVOID Dst, PVOID Src);
template <class T>
struct _klist_entry {
struct _klist_entry<T> *FLink, *BLink;
T Value;
public:
_klist_entry() {FLink = NULL; BLink = NULL;}
};
template <class T>
class klist {
public:
BOOLEAN Insert(const T &Val, BOOLEAN InsertHead = TRUE);
BOOLEAN Insert(const T &Val, const T &Refer, BOOLEAN InsertAfter);
BOOLEAN Delete(const T &Val);
void Destroy ();
public:
ULONG Count() const { return m_Nodes; }
T *First();
T *Last();
T *Next();
T *Prev();
T *operator[] (ULONG Index);
BOOLEAN Exists(const T& Val);
T* Find(const T& Val);
T* Find(const T& Dst, COMPAREPROC CompareProc);
public:
klist() : m_Nodes(0), m_ListHead(0), m_ListTail(0), m_CurNode(0) {};
void Release() { Destroy (); }
private:
typedef struct _klist_entry<T> KNODE;
ULONG m_Nodes;
KNODE *m_ListHead, *m_ListTail, *m_CurNode;
};
template <class T>
BOOLEAN klist<T>::Insert(const T &Val, BOOLEAN InsertHead /*= TRUE*/)
{
KNODE *node;
KNODE *p = m_ListHead;
while (p != NULL) {
if (p->Value == Val) {
return TRUE;
}
p = p->FLink;
}
node = new KNODE;
node->Value = Val;
if (m_ListHead == NULL) {
m_ListHead = m_ListTail = node;
return TRUE;
}
if (InsertHead) {
node->FLink = m_ListHead;
node->FLink->BLink = node;
m_ListHead = node;
}
else {
node->BLink = m_ListTail;
node->BLink->FLink = node;
m_ListTail = node;
}
m_Nodes++;
return TRUE;
}
template <class T>
BOOLEAN klist<T>::Insert(const T &Val, const T &Refer, BOOLEAN InsertAfter)
{
KNODE *node;
KNODE *p = m_ListHead;
while (p != NULL) {
if (p->Value == Refer) {
break;
}
p = p->FLink;
}
if (p == NULL) {
return FALSE;
}
node = new KNODE;
node->Value = Val;
if (InsertAfter) {
if (p == m_ListTail) {
m_ListTail = node;
}
node->FLink = p->FLink;
node->BLink = p;
if (p->FLink != NULL) {
p->FLink->BLink = node;
}
p->FLink = node;
}
else {
if (p == m_ListHead)
m_ListHead = node;
node->FLink = p;
node->BLink = p->BLink;
if (p->BLink != NULL) {
p->BLink->FLink = node;
}
p->BLink = node;
}
m_Nodes++;
return TRUE;
}
template <class T>
BOOLEAN klist<T>::Exists( const T& Val )
{
KNODE* p = m_ListHead;
while( p ) {
if( p->Value == Val )
return TRUE;
p = p->FLink;
}
return FALSE;
}
template <class T>
T* klist<T>::Find( const T& Val )
{
KNODE* p = m_ListHead;
while(p != NULL) {
if(p->Value == Val) {
return &p->Value;
}
p = p->FLink;
}
return 0;
}
template <class T>
T* klist<T>::Find( const T& Dst, COMPAREPROC CompareProc )
{
KNODE* p = m_ListHead;
while(p != NULL) {
if(CompareProc(&Dst, &p->Value)) {
return &p->Value;
}
p = p->FLink;
}
return 0;
}
template <class T>
BOOLEAN klist<T>::Delete(const T &Val)
{
KNODE *p = m_ListHead;
while (p != NULL) {
if (p->Value == Val) {
break;
}
p = p->FLink;
}
if (p == NULL) {
return FALSE;
}
if (p == m_CurNode) {
m_CurNode = p->FLink;
}
if (p->FLink) {
p->FLink->BLink = p->BLink;
}
if (p->BLink) {
p->BLink->FLink = p->FLink;
}
if (p == m_ListHead) {
m_ListHead = p->FLink;
}
if (p == m_ListTail) {
m_ListTail = p->BLink;
}
delete p;
m_Nodes--;
return TRUE;
}
template <class T>
void klist<T>::Destroy()
{
while (m_ListHead != NULL) {
KNODE *p = m_ListHead;
m_ListHead = p->FLink;
delete p;
}
m_Nodes = 0;
m_ListTail = NULL;
}
template <class T>
T* klist<T>::First()
{
m_CurNode = m_ListHead;
return m_ListHead != NULL ? &m_ListHead->Value : NULL;
}
template <class T>
T* klist<T>::Last()
{
m_CurNode = m_ListTail;
return m_ListTail != NULL ? &m_ListTail->Value : NULL;
}
template <class T>
T* klist<T>::Next()
{
if (m_CurNode != NULL && m_CurNode->FLink != NULL) {
m_CurNode = m_CurNode->FLink;
return &m_CurNode->Value;
}
return NULL;
}
template <class T>
T* klist<T>::Prev()
{
if (m_CurNode != NULL && m_CurNode->BLink != NULL) {
m_CurNode = m_CurNode->BLink;
return &m_CurNode->Value;
}
return NULL;
}
template <class T>
T* klist<T>::operator[] (ULONG Index)
{
ULONG i;
KNODE *p = m_ListHead;
for (i = 0; p != NULL; i++) {
if (i == Index) {
return &p->Value;
}
p = p->FLink;
}
return NULL;
}
#endif
|
0cch
|
branches/noname/0.0.1.1/nm_list.h
|
C++
|
lgpl
| 4,605
|
/*
___________________________________________________
Opcode Length Disassembler.
Coded By Ms-Rem ( Ms-Rem@yandex.ru ) ICQ 286370715
---------------------------------------------------
12.08.2005 - fixed many bugs...
09.08.2005 - fixed bug with 0F BA opcode.
07.08.2005 - added SSE, SSE2, SSE3 and 3Dnow instruction support.
06.08.2005 - fixed bug with F6 and F7 opcodes.
29.07.2005 - fixed bug with OP_WORD opcodes.
*/
#include "LDasm.h"
#define OP_NONE 0x00
#define OP_MODRM 0x01
#define OP_DATA_I8 0x02
#define OP_DATA_I16 0x04
#define OP_DATA_I32 0x08
#define OP_DATA_PRE66_67 0x10
#define OP_WORD 0x20
#define OP_REL32 0x40
#define UCHAR unsigned char
#define ULONG unsigned long
#define PVOID void*
#define PUCHAR unsigned char*
#define BOOLEAN char
#define FALSE 0
#define TRUE 1
UCHAR OpcodeFlags[256] =
{
OP_MODRM, // 00
OP_MODRM, // 01
OP_MODRM, // 02
OP_MODRM, // 03
OP_DATA_I8, // 04
OP_DATA_PRE66_67, // 05
OP_NONE, // 06
OP_NONE, // 07
OP_MODRM, // 08
OP_MODRM, // 09
OP_MODRM, // 0A
OP_MODRM, // 0B
OP_DATA_I8, // 0C
OP_DATA_PRE66_67, // 0D
OP_NONE, // 0E
OP_NONE, // 0F
OP_MODRM, // 10
OP_MODRM, // 11
OP_MODRM, // 12
OP_MODRM, // 13
OP_DATA_I8, // 14
OP_DATA_PRE66_67, // 15
OP_NONE, // 16
OP_NONE, // 17
OP_MODRM, // 18
OP_MODRM, // 19
OP_MODRM, // 1A
OP_MODRM, // 1B
OP_DATA_I8, // 1C
OP_DATA_PRE66_67, // 1D
OP_NONE, // 1E
OP_NONE, // 1F
OP_MODRM, // 20
OP_MODRM, // 21
OP_MODRM, // 22
OP_MODRM, // 23
OP_DATA_I8, // 24
OP_DATA_PRE66_67, // 25
OP_NONE, // 26
OP_NONE, // 27
OP_MODRM, // 28
OP_MODRM, // 29
OP_MODRM, // 2A
OP_MODRM, // 2B
OP_DATA_I8, // 2C
OP_DATA_PRE66_67, // 2D
OP_NONE, // 2E
OP_NONE, // 2F
OP_MODRM, // 30
OP_MODRM, // 31
OP_MODRM, // 32
OP_MODRM, // 33
OP_DATA_I8, // 34
OP_DATA_PRE66_67, // 35
OP_NONE, // 36
OP_NONE, // 37
OP_MODRM, // 38
OP_MODRM, // 39
OP_MODRM, // 3A
OP_MODRM, // 3B
OP_DATA_I8, // 3C
OP_DATA_PRE66_67, // 3D
OP_NONE, // 3E
OP_NONE, // 3F
OP_NONE, // 40
OP_NONE, // 41
OP_NONE, // 42
OP_NONE, // 43
OP_NONE, // 44
OP_NONE, // 45
OP_NONE, // 46
OP_NONE, // 47
OP_NONE, // 48
OP_NONE, // 49
OP_NONE, // 4A
OP_NONE, // 4B
OP_NONE, // 4C
OP_NONE, // 4D
OP_NONE, // 4E
OP_NONE, // 4F
OP_NONE, // 50
OP_NONE, // 51
OP_NONE, // 52
OP_NONE, // 53
OP_NONE, // 54
OP_NONE, // 55
OP_NONE, // 56
OP_NONE, // 57
OP_NONE, // 58
OP_NONE, // 59
OP_NONE, // 5A
OP_NONE, // 5B
OP_NONE, // 5C
OP_NONE, // 5D
OP_NONE, // 5E
OP_NONE, // 5F
OP_NONE, // 60
OP_NONE, // 61
OP_MODRM, // 62
OP_MODRM, // 63
OP_NONE, // 64
OP_NONE, // 65
OP_NONE, // 66
OP_NONE, // 67
OP_DATA_PRE66_67, // 68
OP_MODRM | OP_DATA_PRE66_67, // 69
OP_DATA_I8, // 6A
OP_MODRM | OP_DATA_I8, // 6B
OP_NONE, // 6C
OP_NONE, // 6D
OP_NONE, // 6E
OP_NONE, // 6F
OP_DATA_I8, // 70
OP_DATA_I8, // 71
OP_DATA_I8, // 72
OP_DATA_I8, // 73
OP_DATA_I8, // 74
OP_DATA_I8, // 75
OP_DATA_I8, // 76
OP_DATA_I8, // 77
OP_DATA_I8, // 78
OP_DATA_I8, // 79
OP_DATA_I8, // 7A
OP_DATA_I8, // 7B
OP_DATA_I8, // 7C
OP_DATA_I8, // 7D
OP_DATA_I8, // 7E
OP_DATA_I8, // 7F
OP_MODRM | OP_DATA_I8, // 80
OP_MODRM | OP_DATA_PRE66_67, // 81
OP_MODRM | OP_DATA_I8, // 82
OP_MODRM | OP_DATA_I8, // 83
OP_MODRM, // 84
OP_MODRM, // 85
OP_MODRM, // 86
OP_MODRM, // 87
OP_MODRM, // 88
OP_MODRM, // 89
OP_MODRM, // 8A
OP_MODRM, // 8B
OP_MODRM, // 8C
OP_MODRM, // 8D
OP_MODRM, // 8E
OP_MODRM, // 8F
OP_NONE, // 90
OP_NONE, // 91
OP_NONE, // 92
OP_NONE, // 93
OP_NONE, // 94
OP_NONE, // 95
OP_NONE, // 96
OP_NONE, // 97
OP_NONE, // 98
OP_NONE, // 99
OP_DATA_I16 | OP_DATA_PRE66_67,// 9A
OP_NONE, // 9B
OP_NONE, // 9C
OP_NONE, // 9D
OP_NONE, // 9E
OP_NONE, // 9F
OP_DATA_PRE66_67, // A0
OP_DATA_PRE66_67, // A1
OP_DATA_PRE66_67, // A2
OP_DATA_PRE66_67, // A3
OP_NONE, // A4
OP_NONE, // A5
OP_NONE, // A6
OP_NONE, // A7
OP_DATA_I8, // A8
OP_DATA_PRE66_67, // A9
OP_NONE, // AA
OP_NONE, // AB
OP_NONE, // AC
OP_NONE, // AD
OP_NONE, // AE
OP_NONE, // AF
OP_DATA_I8, // B0
OP_DATA_I8, // B1
OP_DATA_I8, // B2
OP_DATA_I8, // B3
OP_DATA_I8, // B4
OP_DATA_I8, // B5
OP_DATA_I8, // B6
OP_DATA_I8, // B7
OP_DATA_PRE66_67, // B8
OP_DATA_PRE66_67, // B9
OP_DATA_PRE66_67, // BA
OP_DATA_PRE66_67, // BB
OP_DATA_PRE66_67, // BC
OP_DATA_PRE66_67, // BD
OP_DATA_PRE66_67, // BE
OP_DATA_PRE66_67, // BF
OP_MODRM | OP_DATA_I8, // C0
OP_MODRM | OP_DATA_I8, // C1
OP_DATA_I16, // C2
OP_NONE, // C3
OP_MODRM, // C4
OP_MODRM, // C5
OP_MODRM | OP_DATA_I8, // C6
OP_MODRM | OP_DATA_PRE66_67, // C7
OP_DATA_I8 | OP_DATA_I16, // C8
OP_NONE, // C9
OP_DATA_I16, // CA
OP_NONE, // CB
OP_NONE, // CC
OP_DATA_I8, // CD
OP_NONE, // CE
OP_NONE, // CF
OP_MODRM, // D0
OP_MODRM, // D1
OP_MODRM, // D2
OP_MODRM, // D3
OP_DATA_I8, // D4
OP_DATA_I8, // D5
OP_NONE, // D6
OP_NONE, // D7
OP_WORD, // D8
OP_WORD, // D9
OP_WORD, // DA
OP_WORD, // DB
OP_WORD, // DC
OP_WORD, // DD
OP_WORD, // DE
OP_WORD, // DF
OP_DATA_I8, // E0
OP_DATA_I8, // E1
OP_DATA_I8, // E2
OP_DATA_I8, // E3
OP_DATA_I8, // E4
OP_DATA_I8, // E5
OP_DATA_I8, // E6
OP_DATA_I8, // E7
OP_DATA_PRE66_67 | OP_REL32, // E8
OP_DATA_PRE66_67 | OP_REL32, // E9
OP_DATA_I16 | OP_DATA_PRE66_67,// EA
OP_DATA_I8, // EB
OP_NONE, // EC
OP_NONE, // ED
OP_NONE, // EE
OP_NONE, // EF
OP_NONE, // F0
OP_NONE, // F1
OP_NONE, // F2
OP_NONE, // F3
OP_NONE, // F4
OP_NONE, // F5
OP_MODRM, // F6
OP_MODRM, // F7
OP_NONE, // F8
OP_NONE, // F9
OP_NONE, // FA
OP_NONE, // FB
OP_NONE, // FC
OP_NONE, // FD
OP_MODRM, // FE
OP_MODRM | OP_REL32 // FF
};
UCHAR OpcodeFlagsExt[256] =
{
OP_MODRM, // 00
OP_MODRM, // 01
OP_MODRM, // 02
OP_MODRM, // 03
OP_NONE, // 04
OP_NONE, // 05
OP_NONE, // 06
OP_NONE, // 07
OP_NONE, // 08
OP_NONE, // 09
OP_NONE, // 0A
OP_NONE, // 0B
OP_NONE, // 0C
OP_MODRM, // 0D
OP_NONE, // 0E
OP_MODRM | OP_DATA_I8, // 0F
OP_MODRM, // 10
OP_MODRM, // 11
OP_MODRM, // 12
OP_MODRM, // 13
OP_MODRM, // 14
OP_MODRM, // 15
OP_MODRM, // 16
OP_MODRM, // 17
OP_MODRM, // 18
OP_NONE, // 19
OP_NONE, // 1A
OP_NONE, // 1B
OP_NONE, // 1C
OP_NONE, // 1D
OP_NONE, // 1E
OP_NONE, // 1F
OP_MODRM, // 20
OP_MODRM, // 21
OP_MODRM, // 22
OP_MODRM, // 23
OP_MODRM, // 24
OP_NONE, // 25
OP_MODRM, // 26
OP_NONE, // 27
OP_MODRM, // 28
OP_MODRM, // 29
OP_MODRM, // 2A
OP_MODRM, // 2B
OP_MODRM, // 2C
OP_MODRM, // 2D
OP_MODRM, // 2E
OP_MODRM, // 2F
OP_NONE, // 30
OP_NONE, // 31
OP_NONE, // 32
OP_NONE, // 33
OP_NONE, // 34
OP_NONE, // 35
OP_NONE, // 36
OP_NONE, // 37
OP_NONE, // 38
OP_NONE, // 39
OP_NONE, // 3A
OP_NONE, // 3B
OP_NONE, // 3C
OP_NONE, // 3D
OP_NONE, // 3E
OP_NONE, // 3F
OP_MODRM, // 40
OP_MODRM, // 41
OP_MODRM, // 42
OP_MODRM, // 43
OP_MODRM, // 44
OP_MODRM, // 45
OP_MODRM, // 46
OP_MODRM, // 47
OP_MODRM, // 48
OP_MODRM, // 49
OP_MODRM, // 4A
OP_MODRM, // 4B
OP_MODRM, // 4C
OP_MODRM, // 4D
OP_MODRM, // 4E
OP_MODRM, // 4F
OP_MODRM, // 50
OP_MODRM, // 51
OP_MODRM, // 52
OP_MODRM, // 53
OP_MODRM, // 54
OP_MODRM, // 55
OP_MODRM, // 56
OP_MODRM, // 57
OP_MODRM, // 58
OP_MODRM, // 59
OP_MODRM, // 5A
OP_MODRM, // 5B
OP_MODRM, // 5C
OP_MODRM, // 5D
OP_MODRM, // 5E
OP_MODRM, // 5F
OP_MODRM, // 60
OP_MODRM, // 61
OP_MODRM, // 62
OP_MODRM, // 63
OP_MODRM, // 64
OP_MODRM, // 65
OP_MODRM, // 66
OP_MODRM, // 67
OP_MODRM, // 68
OP_MODRM, // 69
OP_MODRM, // 6A
OP_MODRM, // 6B
OP_MODRM, // 6C
OP_MODRM, // 6D
OP_MODRM, // 6E
OP_MODRM, // 6F
OP_MODRM | OP_DATA_I8, // 70
OP_MODRM | OP_DATA_I8, // 71
OP_MODRM | OP_DATA_I8, // 72
OP_MODRM | OP_DATA_I8, // 73
OP_MODRM, // 74
OP_MODRM, // 75
OP_MODRM, // 76
OP_NONE, // 77
OP_NONE, // 78
OP_NONE, // 79
OP_NONE, // 7A
OP_NONE, // 7B
OP_MODRM, // 7C
OP_MODRM, // 7D
OP_MODRM, // 7E
OP_MODRM, // 7F
OP_DATA_PRE66_67 | OP_REL32, // 80
OP_DATA_PRE66_67 | OP_REL32, // 81
OP_DATA_PRE66_67 | OP_REL32, // 82
OP_DATA_PRE66_67 | OP_REL32, // 83
OP_DATA_PRE66_67 | OP_REL32, // 84
OP_DATA_PRE66_67 | OP_REL32, // 85
OP_DATA_PRE66_67 | OP_REL32, // 86
OP_DATA_PRE66_67 | OP_REL32, // 87
OP_DATA_PRE66_67 | OP_REL32, // 88
OP_DATA_PRE66_67 | OP_REL32, // 89
OP_DATA_PRE66_67 | OP_REL32, // 8A
OP_DATA_PRE66_67 | OP_REL32, // 8B
OP_DATA_PRE66_67 | OP_REL32, // 8C
OP_DATA_PRE66_67 | OP_REL32, // 8D
OP_DATA_PRE66_67 | OP_REL32, // 8E
OP_DATA_PRE66_67 | OP_REL32, // 8F
OP_MODRM, // 90
OP_MODRM, // 91
OP_MODRM, // 92
OP_MODRM, // 93
OP_MODRM, // 94
OP_MODRM, // 95
OP_MODRM, // 96
OP_MODRM, // 97
OP_MODRM, // 98
OP_MODRM, // 99
OP_MODRM, // 9A
OP_MODRM, // 9B
OP_MODRM, // 9C
OP_MODRM, // 9D
OP_MODRM, // 9E
OP_MODRM, // 9F
OP_NONE, // A0
OP_NONE, // A1
OP_NONE, // A2
OP_MODRM, // A3
OP_MODRM | OP_DATA_I8, // A4
OP_MODRM, // A5
OP_NONE, // A6
OP_NONE, // A7
OP_NONE, // A8
OP_NONE, // A9
OP_NONE, // AA
OP_MODRM, // AB
OP_MODRM | OP_DATA_I8, // AC
OP_MODRM, // AD
OP_MODRM, // AE
OP_MODRM, // AF
OP_MODRM, // B0
OP_MODRM, // B1
OP_MODRM, // B2
OP_MODRM, // B3
OP_MODRM, // B4
OP_MODRM, // B5
OP_MODRM, // B6
OP_MODRM, // B7
OP_NONE, // B8
OP_NONE, // B9
OP_MODRM | OP_DATA_I8, // BA
OP_MODRM, // BB
OP_MODRM, // BC
OP_MODRM, // BD
OP_MODRM, // BE
OP_MODRM, // BF
OP_MODRM, // C0
OP_MODRM, // C1
OP_MODRM | OP_DATA_I8, // C2
OP_MODRM, // C3
OP_MODRM | OP_DATA_I8, // C4
OP_MODRM | OP_DATA_I8, // C5
OP_MODRM | OP_DATA_I8, // C6
OP_MODRM, // C7
OP_NONE, // C8
OP_NONE, // C9
OP_NONE, // CA
OP_NONE, // CB
OP_NONE, // CC
OP_NONE, // CD
OP_NONE, // CE
OP_NONE, // CF
OP_MODRM, // D0
OP_MODRM, // D1
OP_MODRM, // D2
OP_MODRM, // D3
OP_MODRM, // D4
OP_MODRM, // D5
OP_MODRM, // D6
OP_MODRM, // D7
OP_MODRM, // D8
OP_MODRM, // D9
OP_MODRM, // DA
OP_MODRM, // DB
OP_MODRM, // DC
OP_MODRM, // DD
OP_MODRM, // DE
OP_MODRM, // DF
OP_MODRM, // E0
OP_MODRM, // E1
OP_MODRM, // E2
OP_MODRM, // E3
OP_MODRM, // E4
OP_MODRM, // E5
OP_MODRM, // E6
OP_MODRM, // E7
OP_MODRM, // E8
OP_MODRM, // E9
OP_MODRM, // EA
OP_MODRM, // EB
OP_MODRM, // EC
OP_MODRM, // ED
OP_MODRM, // EE
OP_MODRM, // EF
OP_MODRM, // F0
OP_MODRM, // F1
OP_MODRM, // F2
OP_MODRM, // F3
OP_MODRM, // F4
OP_MODRM, // F5
OP_MODRM, // F6
OP_MODRM, // F7
OP_MODRM, // F8
OP_MODRM, // F9
OP_MODRM, // FA
OP_MODRM, // FB
OP_MODRM, // FC
OP_MODRM, // FD
OP_MODRM, // FE
OP_NONE // FF
};
unsigned long __fastcall SizeOfCode(void *Code, unsigned char **pOpcode)
{
PUCHAR cPtr;
UCHAR Flags;
BOOLEAN PFX66, PFX67;
BOOLEAN SibPresent;
UCHAR iMod, iRM, iReg;
UCHAR OffsetSize, Add;
UCHAR Opcode;
OffsetSize = 0;
PFX66 = FALSE;
PFX67 = FALSE;
cPtr = (PUCHAR)Code;
while ( (*cPtr == 0x2E) || (*cPtr == 0x3E) || (*cPtr == 0x36) ||
(*cPtr == 0x26) || (*cPtr == 0x64) || (*cPtr == 0x65) ||
(*cPtr == 0xF0) || (*cPtr == 0xF2) || (*cPtr == 0xF3) ||
(*cPtr == 0x66) || (*cPtr == 0x67) )
{
if (*cPtr == 0x66) PFX66 = TRUE;
if (*cPtr == 0x67) PFX67 = TRUE;
cPtr++;
if (cPtr > (PUCHAR)Code + 16) return 0;
}
Opcode = *cPtr;
if (pOpcode) *pOpcode = cPtr;
if (*cPtr == 0x0F)
{
cPtr++;
Flags = OpcodeFlagsExt[*cPtr];
} else
{
Flags = OpcodeFlags[Opcode];
if (Opcode >= 0xA0 && Opcode <= 0xA3) PFX66 = !PFX66;
}
cPtr++;
if (Flags & OP_WORD)cPtr++;
if (Flags & OP_MODRM)
{
iMod = *cPtr >> 6;
iReg = (*cPtr & 0x38) >> 3;
iRM = *cPtr & 7;
cPtr++;
if ((Opcode == 0xF6) && !iReg) Flags |= OP_DATA_I8;
if ((Opcode == 0xF7) && !iReg) Flags |= OP_DATA_PRE66_67;
SibPresent = !PFX67 & (iRM == 4);
switch (iMod)
{
case 0:
if ( PFX67 && (iRM == 6)) OffsetSize = 2;
if (!PFX67 && (iRM == 5)) OffsetSize = 4;
break;
case 1: OffsetSize = 1;
break;
case 2: if (PFX67) OffsetSize = 2; else OffsetSize = 4;
break;
case 3: SibPresent = FALSE;
}
if (SibPresent)
{
if (((*cPtr & 7) == 5) && ( (!iMod) || (iMod == 2) )) OffsetSize = 4;
cPtr++;
}
cPtr = (PUCHAR)(ULONG)cPtr + OffsetSize;
}
if (Flags & OP_DATA_I8) cPtr++;
if (Flags & OP_DATA_I16) cPtr += 2;
if (Flags & OP_DATA_I32) cPtr += 4;
if (PFX66) Add = 2; else Add = 4;
if (Flags & OP_DATA_PRE66_67) cPtr += Add;
return (ULONG)cPtr - (ULONG)Code;
}
unsigned long __fastcall SizeOfProc(void *Proc)
{
ULONG Length;
PUCHAR pOpcode;
ULONG Result = 0;
do
{
Length = SizeOfCode(Proc, &pOpcode);
Result += Length;
if ((Length == 1) && (*pOpcode == 0xC3)) break;
Proc = (PVOID)((ULONG)Proc + Length);
} while (Length);
return Result;
}
char __fastcall IsRelativeCmd(unsigned char *pOpcode)
{
UCHAR Flags;
if (*pOpcode == 0x0F) Flags = OpcodeFlagsExt[*(PUCHAR)((ULONG)pOpcode + 1)];
else Flags = OpcodeFlags[*pOpcode];
return (Flags & OP_REL32);
}
|
0cch
|
branches/noname/0.0.1.1/disasm/LDasm.c
|
C
|
lgpl
| 24,936
|
#ifndef _LDASM_
#define _LDASM_
#ifdef __cplusplus
extern "C" {
#endif
unsigned long __fastcall SizeOfCode(void *Code, unsigned char **pOpcode);
unsigned long __fastcall SizeOfProc(void *Proc);
char __fastcall IsRelativeCmd(unsigned char *pOpcode);
#ifdef __cplusplus
}
#endif
#endif
|
0cch
|
branches/noname/0.0.1.1/disasm/LDasm.h
|
C
|
lgpl
| 306
|
#include "nm_event.h"
NTSTATUS kevent::Create( EVENT_TYPE Type /*= NotificationEvent*/, BOOLEAN InitialState /*= FALSE*/ )
{
NTSTATUS ns;
OBJECT_ATTRIBUTES oa;
m_Event = 0;
InitializeObjectAttributes(&oa,
NULL,
OBJ_KERNEL_HANDLE,
0,
NULL);
ns = ZwCreateEvent(&m_Event,
EVENT_ALL_ACCESS,
&oa,
Type,
InitialState);
return ns;
}
NTSTATUS kevent::Create( PWCHAR Name, EVENT_TYPE Type /*= NotificationEvent*/, BOOLEAN InitialState /*= FALSE*/ )
{
NTSTATUS ns;
OBJECT_ATTRIBUTES oa;
UNICODE_STRING EventName;
m_Event = 0;
RtlInitUnicodeString(&EventName, Name);
InitializeObjectAttributes(&oa,
&EventName,
OBJ_KERNEL_HANDLE,
0,
NULL);
ns = ZwCreateEvent(&m_Event,
EVENT_ALL_ACCESS,
&oa,
Type,
InitialState);
return ns;
}
NTSTATUS kevent::Wait( PLARGE_INTEGER Timeout /*= NULL*/, BOOLEAN Alertable /*= FALSE*/ )
{
return ZwWaitForSingleObject(m_Event, Alertable, Timeout);
}
NTSTATUS kevent::Set( PLONG PreviousState )
{
return ZwSetEvent(m_Event, PreviousState);
}
|
0cch
|
branches/noname/0.0.1.1/nm_event.cpp
|
C++
|
lgpl
| 1,074
|
#include "nm_vector.h"
|
0cch
|
branches/noname/0.0.1.1/nm_vector.cpp
|
C++
|
lgpl
| 24
|
#ifndef __NONAME_STACK_H__
#define __NONAME_STACK_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#define DEFAULT_STACK_SIZE 64
template <class T>
class kstack {
public:
kstack();
kstack(ULONG Size);
void Release();
ULONG Push(const T &Val);
ULONG pop(T &Val);
ULONG GetStackPointer() {return m_CurrentSP;}
private:
T *m_Stack;
ULONG m_StackSize;
ULONG m_CurrentSP;
};
template <class T>
kstack<T>::kstack()
{
m_StackSize = DEFAULT_STACK_SIZE;
m_Stack = new T[m_StackSize];
m_CurrentSP = m_StackSize;
}
template <class T>
kstack<T>::kstack (ULONG Size)
{
m_StackSize = Size;
m_Stack = new T[m_StackSize];
m_CurrentSP = m_StackSize;
}
template <class T>
void kstack<T>::Release ()
{
if (m_Stack != NULL)
delete[] m_Stack;
}
template <class T>
ULONG kstack<T>::Push(const T &Val)
{
T *tmp;
ULONG i, j;
if (m_CurrentSP == 0) {
tmp = new T[m_StackSize * 2];
for (i = 0, j = m_StackSize; i < m_StackSize; i++, j++) {
tmp[j] = m_Stack[i];
}
delete[] m_Stack;
m_Stack = tmp;
m_CurrentSP = m_StackSize;
m_StackSize *= 2;
}
m_Stack[--m_CurrentSP] = Val;
return m_CurrentSP;
}
template <class T>
ULONG kstack<T>::pop (T &val)
{
if (m_CurrentSP == m_StackSize) {
return 0;
}
val = m_Stack[cur_sp++];
return m_CurrentSP;
}
#endif
|
0cch
|
branches/noname/0.0.1.1/nm_stack.h
|
C++
|
lgpl
| 1,369
|
#ifndef __NONAME_STRING_H__
#define __NONAME_STRING_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#include "nm_mem.h"
#include <ntstrsafe.h>
class kstringw {
public:
kstringw();
kstringw(PWCHAR String);
kstringw(PUNICODE_STRING UniString);
void Release();
PWCHAR Allocate(ULONG size, BOOLEAN SaveData = FALSE);
void Append(WCHAR ch);
void Attach(PWCHAR String);
INT Compare(PWCHAR String, BOOLEAN CaseInsensitive = TRUE);
void Copy(PWCHAR String, ULONG Cch = 0);
PWCHAR Detach();
void Empty();
INT Find(WCHAR ch, INT Start);
INT Find(PWCHAR String, INT Start);
INT Format(__in PWCHAR Formats, ...);
WCHAR GetAt(__in ULONG idx);
INT GetLength() const;
PWCHAR GetString() const;
PUNICODE_STRING GetUnicodeString();
BOOLEAN IsEmpty() const;
void Left(ULONG Cch);
void MakeUpper();
void MakeLower();
void Mid(ULONG Start, ULONG Cch);
void Right(ULONG Cch);
INT Replace(PWCHAR Old, PWCHAR New);
INT ReverseFind(WCHAR ch);
WCHAR SetAt(ULONG pos, WCHAR ch);
operator PWCHAR() const;
operator PUNICODE_STRING();
kstringw& operator=(PWCHAR String);
kstringw& operator=(PUNICODE_STRING UniString);
kstringw& operator=(const kstringw& str);
BOOLEAN operator==(kstringw& str2);
BOOLEAN operator==(PWCHAR str2);
const kstringw& operator+=(PUNICODE_STRING UniString);
const kstringw& operator+=(PWCHAR String);
const kstringw& operator+=(const kstringw& str);
const kstringw& operator+=(WCHAR ch);
WCHAR operator[](ULONG idx);
private:
PWCHAR m_stringw;
ULONG m_len;
UNICODE_STRING m_UniString;
};
#endif
|
0cch
|
branches/noname/0.0.1.1/nm_string.h
|
C++
|
lgpl
| 1,602
|
#include "nm_cppcrt.h"
#pragma section(".CRT$XCA",long,read)
KCRT_FUNCTION xc_a[] = { 0 };
#pragma section(".CRT$XCZ",long,read)
KCRT_FUNCTION xc_z[] = { 0 };
#pragma data_seg()
#pragma comment(linker, "/merge:.CRT=.data")
AtExitCall* AtExitCall::m_ExitList = 0;
#ifdef __cplusplus
extern "C" {
#endif
PDRIVER_UNLOAD g_user_driver_unload = 0;
void __cdecl crtlib_startup()
{
KCRT_FUNCTION* crt_func;
for(crt_func = xc_a; crt_func < xc_z; crt_func++) {
if(*crt_func) {
(*crt_func)();
}
}
}
void __cdecl crtlib_finalize()
{
AtExitCall::do_exit_calls();
}
void crt_driver_unload(PDRIVER_OBJECT drvobj)
{
g_user_driver_unload(drvobj);
crtlib_finalize();
}
int __cdecl atexit(KCRT_FUNCTION crt_func)
{
return (new AtExitCall(crt_func) == 0) ? (*crt_func)(), 1 : 0;
}
NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegPath)
{
NTSTATUS ns;
crtlib_startup();
ns = NM_DriverEntry(DriverObject, RegPath);
if(!NT_SUCCESS(ns)) {
crtlib_finalize();
}
g_user_driver_unload = DriverObject->DriverUnload;
if(g_user_driver_unload != NULL) {
DriverObject->DriverUnload = crt_driver_unload;
}
return ns;
}
#ifdef __cplusplus
}
#endif
|
0cch
|
branches/noname/0.0.1.1/nm_cppcrt.cpp
|
C++
|
lgpl
| 1,289
|
#include "nm_inlinehook.h"
VOID __stdcall kinlinehook::DpcLock(struct _KDPC *Dpc, PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2)
{
__asm cli;
InterlockedIncrement(&((PDPCLOCK_CONTEXT)DeferredContext)->Locks);
do {
__asm pause;
} while (!((PDPCLOCK_CONTEXT)DeferredContext)->Release);
InterlockedDecrement(&((PDPCLOCK_CONTEXT)DeferredContext)->Locks);
__asm sti;
}
BOOLEAN kinlinehook::AutoHook(PVOID Dst, PVOID Src, PVOID *Proxy)
{
KIRQL OldIrql;
PRKDPC Dpc;
DPCLOCK_CONTEXT DpcLockContext;
CCHAR Processor;
const ULONG MicroSeconds = 1000 * 50;
const ULONG Tag = 'nmlk';
UCHAR JmpTmp[5] = {0xe9, 0x90, 0x90, 0x90, 0x90};
ULONG CodeLength = 0;
PUCHAR OpCodePtr;
ULONG TmpJmpAddr = 0;
ULONG TmpJmpOff = 0;
//
// Prepare hook.
//
if (Dst == NULL || Src == NULL || Proxy == NULL) {
return FALSE;
}
//
// Calculate code length.
//
while (CodeLength < 5) {
CodeLength += SizeOfCode((PUCHAR)Dst + CodeLength, &OpCodePtr);
if (*OpCodePtr == 0xe8 || *OpCodePtr == 0xe9) {
TmpJmpAddr = (ULONG)(OpCodePtr + 5 + *(ULONG *)(OpCodePtr + 1));
TmpJmpOff = CodeLength - 5;
}
//
// Not support some code.
//
if (*OpCodePtr == 0xeb) {
//
// I will not support some opcode, such as 0xeb and so on.
//
return FALSE;
}
}
//
// Prepare proxy routine addr. And calculate jump address.
//
*Proxy = ExAllocatePoolWithTag(NonPagedPool, CodeLength + 5, Tag);
RtlCopyMemory(*Proxy, Dst, CodeLength);
*((PUCHAR)*Proxy + CodeLength) = 0xe9;
*(ULONG *)((PUCHAR)*Proxy + CodeLength + 1) = (ULONG)Dst - ((ULONG)*Proxy + 5);
if (TmpJmpAddr != 0) {
*(ULONG *)((PUCHAR)*Proxy + TmpJmpOff + 1) = TmpJmpAddr - ((ULONG)*Proxy + TmpJmpOff + 5);
}
*(ULONG *)&JmpTmp[1] = (ULONG)Src - ((ULONG)Dst + 5);
//
// Raise Irql
//
OldIrql = KeRaiseIrqlToDpcLevel();
if (KeNumberProcessors > 1) {
//
// Let current thread work on the processor 0.
//
KeSetAffinityThread(PsGetCurrentThread(), (KAFFINITY)1);
if (KeGetCurrentProcessorNumber() != 0) {
ExFreePoolWithTag(*Proxy, Tag);
*Proxy = NULL;
return FALSE;
}
DpcLockContext.Dpcs = (PKDPC)ExAllocatePoolWithTag(NonPagedPool, (KeNumberProcessors - 1) * sizeof(KDPC), Tag);
for (Processor = 1; Processor < KeNumberProcessors; Processor++) {
Dpc = &DpcLockContext.Dpcs[Processor];
KeInitializeDpc(Dpc, kinlinehook::DpcLock, &DpcLockContext);
KeSetImportanceDpc(Dpc, HighImportance);
KeSetTargetProcessorDpc(Dpc, Processor);
KeInsertQueueDpc(Dpc, NULL, NULL);
}
while (DpcLockContext.Locks != (KeNumberProcessors - 1)) {
KeStallExecutionProcessor(MicroSeconds);
}
kinlinehook::WPOFF();
RtlCopyMemory(Dst, JmpTmp, 5);
kinlinehook::WPOFF();
DpcLockContext.Release = TRUE;
while (DpcLockContext.Locks != 0) {
KeStallExecutionProcessor(MicroSeconds);
}
ExFreePoolWithTag(DpcLockContext.Dpcs, Tag);
}
else {
kinlinehook::WPOFF();
RtlCopyMemory(Dst, JmpTmp, 5);
kinlinehook::WPOFF();
}
KeLowerIrql(OldIrql);
return TRUE;
}
BOOLEAN kinlinehook::Hook(HOOKPROC HookProc, PVOID Context)
{
KIRQL OldIrql;
PRKDPC Dpc;
DPCLOCK_CONTEXT DpcLockContext;
CCHAR Processor;
const ULONG MicroSeconds = 1000 * 50;
const ULONG Tag = 'nmlk';
BOOLEAN Ret = FALSE;
//
// Raise Irql
//
OldIrql = KeRaiseIrqlToDpcLevel();
if (KeNumberProcessors > 1) {
//
// Let current thread work on the processor 0.
//
KeSetAffinityThread(PsGetCurrentThread(), (KAFFINITY)1);
if (KeGetCurrentProcessorNumber() != 0) {
return FALSE;
}
DpcLockContext.Dpcs = (PKDPC)ExAllocatePoolWithTag(NonPagedPool, (KeNumberProcessors - 1) * sizeof(KDPC), Tag);
for (Processor = 1; Processor < KeNumberProcessors; Processor++) {
Dpc = &DpcLockContext.Dpcs[Processor];
KeInitializeDpc(Dpc, kinlinehook::DpcLock, &DpcLockContext);
KeSetImportanceDpc(Dpc, HighImportance);
KeSetTargetProcessorDpc(Dpc, Processor);
KeInsertQueueDpc(Dpc, NULL, NULL);
}
while (DpcLockContext.Locks != (KeNumberProcessors - 1)) {
KeStallExecutionProcessor(MicroSeconds);
}
kinlinehook::WPOFF();
if (ARGUMENT_PRESENT(HookProc)) {
Ret = HookProc(Context);
}
kinlinehook::WPOFF();
DpcLockContext.Release = TRUE;
while (DpcLockContext.Locks != 0) {
KeStallExecutionProcessor(MicroSeconds);
}
ExFreePoolWithTag(DpcLockContext.Dpcs, Tag);
}
else {
kinlinehook::WPOFF();
if (ARGUMENT_PRESENT(HookProc)) {
Ret = HookProc(Context);
}
kinlinehook::WPOFF();
}
KeLowerIrql(OldIrql);
return Ret;
}
|
0cch
|
branches/noname/0.0.1.1/nm_inlinehook.cpp
|
C++
|
lgpl
| 4,780
|
#include "nm_file.h"
kfile::kfile()
{
m_filehandle = 0;
m_fileobj = NULL;
}
void kfile::Release()
{
Close();
}
VOID kfile::Close()
{
if (m_fileobj != NULL) {
ObDereferenceObject(m_fileobj);
m_fileobj = NULL;
}
if (m_filehandle != NULL) {
ZwClose(m_filehandle);
m_filehandle = 0;
}
}
NTSTATUS kfile::Create( PWCHAR FileName, ULONG CreateDisposition /*= FILE_OPEN*/, ACCESS_MASK DesiredAccess /*= GENERIC_READ*/, ULONG ShareAccess /*= FILE_SHARE_READ */ )
{
UNICODE_STRING Name;
RtlInitUnicodeString(&Name, FileName);
return Create(&Name, CreateDisposition, DesiredAccess, ShareAccess);
}
NTSTATUS kfile::Create( PUNICODE_STRING FileName, ULONG CreateDisposition /*= FILE_OPEN*/, ACCESS_MASK DesiredAccess /*= GENERIC_READ*/, ULONG ShareAccess /*= FILE_SHARE_READ */ )
{
NTSTATUS ns;
OBJECT_ATTRIBUTES oa;
IO_STATUS_BLOCK Iob;
Close();
InitializeObjectAttributes(&oa, FileName, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, 0, NULL);
ns = IoCreateFile(&m_filehandle,
DesiredAccess | SYNCHRONIZE,
&oa,
&Iob,
NULL,
FILE_ATTRIBUTE_NORMAL,
ShareAccess,
CreateDisposition,
FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
NULL,
0,
CreateFileTypeNone,
NULL,
IO_NO_PARAMETER_CHECKING);
if (!NT_SUCCESS(ns)) {
return ns;
}
ns = ObReferenceObjectByHandle(m_filehandle, 0, *IoFileObjectType, KernelMode, (PVOID *)&m_fileobj, NULL);
if (!NT_SUCCESS(ns)) {
ZwClose(m_filehandle);
m_filehandle = 0;
}
return ns;
}
NTSTATUS kfile::Create( kstringw& FileName, ULONG CreateDisposition /*= FILE_OPEN*/, ACCESS_MASK DesiredAccess /*= GENERIC_READ*/, ULONG ShareAccess /*= FILE_SHARE_READ */ )
{
return Create((PUNICODE_STRING)FileName, CreateDisposition, DesiredAccess, ShareAccess);
}
NTSTATUS kfile::Delete( BOOLEAN Del /*= TRUE*/ )
{
NTSTATUS ns;
IO_STATUS_BLOCK Iob;
FILE_DISPOSITION_INFORMATION FileDispInfo;
FileDispInfo.DeleteFile = Del;
ns = ZwSetInformationFile(m_filehandle,
&Iob,
&FileDispInfo,
sizeof(FileDispInfo),
FileDispositionInformation);
return ns;
}
NTSTATUS kfile::Flush()
{
IO_STATUS_BLOCK Iob;
PDEVICE_OBJECT deviceObject;
PIRP irp;
PIO_STACK_LOCATION irpSp;
deviceObject = IoGetRelatedDeviceObject( m_fileobj );
//
// Allocate and initialize the I/O Request Packet (IRP) for this operation.
//
irp = IoAllocateIrp( deviceObject->StackSize, FALSE );
if (!irp) {
return STATUS_INSUFFICIENT_RESOURCES;
}
irp->Tail.Overlay.OriginalFileObject = m_fileobj;
irp->Tail.Overlay.Thread = PsGetCurrentThread();
irp->RequestorMode = KernelMode;
irp->UserEvent = (PKEVENT) NULL;
irp->UserIosb = &Iob;
irp->Overlay.AsynchronousParameters.UserApcRoutine = (PIO_APC_ROUTINE) NULL;
//
// Get a pointer to the stack location for the first driver. This is used
// to pass the original function codes and parameters.
//
irpSp = IoGetNextIrpStackLocation( irp );
irpSp->MajorFunction = IRP_MJ_FLUSH_BUFFERS;
irpSp->FileObject = m_fileobj;
return IoCallDriver(deviceObject, irp);
}
HANDLE kfile::GetHandle()
{
return m_filehandle;
}
NTSTATUS kfile::GetName(kstringw& String)
{
kstringw Path;
NTSTATUS ns;
INT Pos;
ULONG RightCch;
ns = GetPath(Path);
if (!NT_SUCCESS(ns)) {
return ns;
}
Pos = Path.ReverseFind(L'\\');
if (Pos == -1) {
return STATUS_UNSUCCESSFUL;
}
Pos++;
RightCch = Path.GetLength() - Pos;
Path.Right(RightCch);
return ns;
}
PFILE_OBJECT kfile::GetObject()
{
return m_fileobj;
}
NTSTATUS kfile::GetPath(kstringw& String)
{
PUCHAR Buffer;
kstringw Path;
NTSTATUS ns;
Buffer = new UCHAR[1024];
RtlZeroMemory(Buffer, 1024);
ns = GetPath((PFILE_NAME_INFORMATION)Buffer, 1024 - sizeof(WCHAR));
if (!NT_SUCCESS(ns)) {
delete[] Buffer;
return ns;
}
String.Copy(((PFILE_NAME_INFORMATION)Buffer)->FileName,
((PFILE_NAME_INFORMATION)Buffer)->FileNameLength / sizeof(WCHAR));
delete[] Buffer;
return ns;
}
NTSTATUS kfile::GetPath( PFILE_NAME_INFORMATION NameInfo, ULONG Length)
{
NTSTATUS ns;
IO_STATUS_BLOCK Iob;
return ZwQueryInformationFile(m_filehandle,
&Iob,
&NameInfo,
Length,
FileNameInformation);
}
NTSTATUS kfile::GetSize( PLARGE_INTEGER FileSize )
{
NTSTATUS ns;
IO_STATUS_BLOCK Iob;
FILE_STANDARD_INFORMATION StandardInfo;
ns = ZwQueryInformationFile(m_filehandle,
&Iob,
&StandardInfo,
sizeof(StandardInfo),
FileStandardInformation);
if (!NT_SUCCESS(ns))
{
return FALSE;
}
FileSize->QuadPart = StandardInfo.EndOfFile.QuadPart;
return TRUE;
}
NTSTATUS kfile::Read( PVOID Buffer, ULONG Length, PULONG RetLength /*= NULL*/ )
{
IO_STATUS_BLOCK Iob;
return ZwReadFile(m_filehandle, 0, NULL, NULL, &Iob, Buffer, Length, NULL, NULL);
}
NTSTATUS kfile::Rename( PFILE_RENAME_INFORMATION RenameInfo, ULONG Length )
{
IO_STATUS_BLOCK Iob;
return ZwSetInformationFile(m_filehandle,
&Iob,
RenameInfo,
Length,
FileRenameInformation);
}
NTSTATUS kfile::Rename( kstringw& Name, BOOLEAN ReplaceIfExists )
{
NTSTATUS ns;
PUCHAR Buffer;
PFILE_RENAME_INFORMATION RenameInfo;
Buffer = new UCHAR[1024];
RtlZeroMemory(Buffer, 1024);
RenameInfo = (PFILE_RENAME_INFORMATION)Buffer;
RenameInfo->ReplaceIfExists = ReplaceIfExists;
RenameInfo->RootDirectory = NULL;
RenameInfo->FileNameLength = Name.GetLength() * sizeof(WCHAR);
RtlStringCbCopyW(RenameInfo->FileName, 1024 - sizeof(FILE_RENAME_INFORMATION), Name.GetString());
ns = Rename(RenameInfo, 1024);
delete[] Buffer;
return ns;
}
BOOLEAN kfile::SetPointer( PLARGE_INTEGER DistanceToMove, ULONG Flag /*= FILE_BEGIN*/, PLARGE_INTEGER NewPointer /*= NULL*/ )
{
NTSTATUS Status;
IO_STATUS_BLOCK IoStatusBlock;
FILE_POSITION_INFORMATION CurrentPosition;
FILE_STANDARD_INFORMATION StandardInfo;
LARGE_INTEGER Large;
Large.QuadPart = DistanceToMove->QuadPart;
switch (Flag)
{
case FILE_BEGIN:
CurrentPosition.CurrentByteOffset = Large;
break;
case FILE_CURRENT:
Status = ZwQueryInformationFile(m_filehandle,
&IoStatusBlock,
&CurrentPosition,
sizeof(CurrentPosition),
FilePositionInformation);
if (!NT_SUCCESS(Status))
{
return FALSE;
}
CurrentPosition.CurrentByteOffset.QuadPart += Large.QuadPart;
break;
case FILE_END:
Status = ZwQueryInformationFile(m_filehandle,
&IoStatusBlock,
&StandardInfo,
sizeof(StandardInfo),
FileStandardInformation);
if (!NT_SUCCESS(Status))
{
return FALSE;
}
CurrentPosition.CurrentByteOffset.QuadPart = StandardInfo.EndOfFile.QuadPart + Large.QuadPart;
break;
default:
return FALSE;
}
if (CurrentPosition.CurrentByteOffset.QuadPart < 0)
{
return FALSE;
}
Status = ZwSetInformationFile(m_filehandle,
&IoStatusBlock,
&CurrentPosition,
sizeof(CurrentPosition),
FilePositionInformation);
if (NT_SUCCESS(Status))
{
if (ARGUMENT_PRESENT(NewPointer))
{
*NewPointer = CurrentPosition.CurrentByteOffset;
}
return TRUE;
}
else
{
return FALSE;
}
}
NTSTATUS kfile::SetEnd(PLARGE_INTEGER EndPos)
{
IO_STATUS_BLOCK Iob;
FILE_END_OF_FILE_INFORMATION FileEnd;
FileEnd.EndOfFile.QuadPart = EndPos->QuadPart;
return ZwSetInformationFile(m_filehandle,
&Iob,
&FileEnd,
sizeof(FileEnd),
FileEndOfFileInformation);
}
NTSTATUS kfile::Write( PVOID Buffer, ULONG Length, PULONG RetLength /*= NULL*/ )
{
IO_STATUS_BLOCK Iob;
return ZwWriteFile(m_filehandle, 0, NULL, NULL, &Iob, Buffer, Length, NULL, NULL);
}
|
0cch
|
branches/noname/0.0.1.1/nm_file.cpp
|
C++
|
lgpl
| 7,735
|
#include "nm_crique.h"
|
0cch
|
branches/noname/0.0.1.1/nm_crique.cpp
|
C++
|
lgpl
| 22
|
#ifndef __NONAME_CPPCRT_H__
#define __NONAME_CPPCRT_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#include "nm_mem.h"
extern "C" NTSTATUS __cdecl NM_DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegPath);
typedef void(__cdecl* KCRT_FUNCTION)();
class AtExitCall {
public:
AtExitCall(KCRT_FUNCTION func) :
m_Func(func), m_Next(m_ExitList) { m_ExitList = this; }
~AtExitCall() { m_Func(); m_ExitList = m_Next; }
public:
static void do_exit_calls() { while(m_ExitList) delete m_ExitList; }
private:
KCRT_FUNCTION m_Func;
AtExitCall* m_Next;
static AtExitCall *m_ExitList;
};
#endif
|
0cch
|
branches/noname/0.0.1.1/nm_cppcrt.h
|
C++
|
lgpl
| 636
|
#ifndef __NONAME_EVENT_H__
#define __NONAME_EVENT_H__
#define NONAME_LIB_USE
#include <ntifs.h>
class kevent {
public:
kevent() : m_Event(0) {}
NTSTATUS Create(EVENT_TYPE Type = NotificationEvent, BOOLEAN InitialState = FALSE);
NTSTATUS Create(PWCHAR Name, EVENT_TYPE Type = NotificationEvent, BOOLEAN InitialState = FALSE);
NTSTATUS Wait(PLARGE_INTEGER Timeout = NULL, BOOLEAN Alertable = FALSE);
NTSTATUS Set(PLONG PreviousState);
private:
HANDLE m_Event;
};
#endif
|
0cch
|
branches/noname/0.0.1.1/nm_event.h
|
C++
|
lgpl
| 497
|
#ifndef __NONAME_WORKTHREAD_H__
#define __NONAME_WORKTHREAD_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#include "nm_mem.h"
typedef VOID (__stdcall *WORKITEMPROC)(PVOID Context);
class kworkthread
{
public:
kworkthread();
void Release();
VOID InsertItem(WORKITEMPROC Address, PVOID Context, PRKEVENT *Event);
HANDLE GetWorkThreadId() { return m_ClientId.UniqueThread; }
protected:
static void __stdcall Run(PVOID Context);
private:
typedef struct _WORK_ITEM {
LIST_ENTRY Next;
WORKITEMPROC StartAddress;
PVOID Context;
KEVENT Event;
} WORK_ITEM, *PWORK_ITEM;
private:
klookaside m_Lookaside;
KEVENT m_InsertEvent;
KEVENT m_SyncEvent;
HANDLE m_ThreadHandle;
CLIENT_ID m_ClientId;
LIST_ENTRY m_ListHeader;
KSPIN_LOCK m_Lock;
BOOLEAN m_Stop;
};
#endif
|
0cch
|
branches/noname/0.0.1.1/nm_workthread.h
|
C++
|
lgpl
| 825
|
#ifndef __NONAME_MEMORY_H__
#define __NONAME_MEMORY_H__
#include <ntifs.h>
#include "nm_undoc.h"
#ifndef NONAME_MEM_TAG
#define NONAME_MEM_TAG 'nonm'
#endif
#ifndef NONAME_MEM_TYPE
#define NONAME_MEM_TYPE PagedPool
#endif
#ifdef NONAME_LIB_USE
#define NONAME_INTER_MEM_TYPE NONAME_MEM_TYPE
#else
#define NONAME_INTER_MEM_TYPE (POOL_TYPE)(NONAME_MEM_TYPE | POOL_QUOTA_FAIL_INSTEAD_OF_RAISE)
#endif
__forceinline
void* __cdecl operator new(size_t size,
POOL_TYPE pool_type,
ULONG pool_tag)
{
ASSERT((pool_type < MaxPoolType) && (0 != size));
if(size == 0) {
return NULL;
}
ASSERT(pool_type == NonPagedPool ||
(KeGetCurrentIrql() < DISPATCH_LEVEL));
return ExAllocatePoolWithQuotaTag(pool_type,
(ULONG)size,
pool_tag);
}
__forceinline
void* __cdecl operator new(size_t size)
{
if(size == 0) {
return NULL;
}
ASSERT((KeGetCurrentIrql() < DISPATCH_LEVEL));
return ExAllocatePoolWithQuotaTag(NONAME_INTER_MEM_TYPE,
(ULONG)size,
NONAME_MEM_TAG);
}
__forceinline
void __cdecl operator delete(void* pointer)
{
ASSERT(NULL != pointer);
if (NULL != pointer) {
ExFreePool(pointer);
}
}
__forceinline
void __cdecl operator delete[](void* pointer)
{
ASSERT(NULL != pointer);
if (NULL != pointer) {
ExFreePool(pointer);
}
}
__forceinline
void DisableMaskableInterrupt()
{
KIRQL Irql = KeRaiseIrqlToSynchLevel();
UCHAR i;
for (i = 0; i < KeNumberProcessors; i++) {
KeSetAffinityThread(KeGetCurrentThread(), 1 << i);
__asm cli
}
KeLowerIrql(Irql);
}
__forceinline
void EnableMaskableInterrupt()
{
KIRQL Irql = KeRaiseIrqlToSynchLevel();
UCHAR i;
for (i = 0; i < KeNumberProcessors; i++) {
KeSetAffinityThread(KeGetCurrentThread(), 1 << i);
__asm sti
}
KeLowerIrql(Irql);
}
__forceinline
void EnableWriteProtect()
{
__asm {
mov eax, cr0
or eax, 10000h
mov cr0, eax
}
EnableMaskableInterrupt();
}
__forceinline
void DisableWriteProtect()
{
DisableMaskableInterrupt();
__asm {
mov eax, cr0
and eax, 0fffeffffh
mov cr0, eax
}
}
class kwps {
public:
kwps() {}
static void Enable() { EnableWriteProtect(); kwps::m_Switch = TRUE; }
static void Disable() { DisableWriteProtect(); kwps::m_Switch = FALSE; }
static BOOLEAN GetSwitch() { return m_Switch; }
private:
static BOOLEAN m_Switch;
};
__forceinline
void KSleep(INT ms)
{
LARGE_INTEGER timeOut;
timeOut.QuadPart = -10000 * ms;
KeDelayExecutionThread( UserMode, false, &timeOut );
}
__forceinline
BOOLEAN KIsMemVaild(PVOID Addr, ULONG Length)
{
ULONG Pages;
ULONG i;
ULONG Va;
Pages = ADDRESS_AND_SIZE_TO_SPAN_PAGES(Addr, Length);
if (Pages > 1000) {
return FALSE;
}
Va = (ULONG)Addr & 0xfffff000;
for (i = 0; i < Pages; i++) {
if (!MmIsAddressValid((PVOID)Va)) {
return FALSE;
}
Va += 0x1000;
}
return TRUE;
}
class klookaside {
#define NM_LOOKASIDE_TAG 'nmls'
public:
klookaside(ULONG Size, ULONG Tag = NM_LOOKASIDE_TAG, POOL_TYPE PoolType = PagedPool);
void Release();
PVOID Allocate();
VOID Free(PVOID Buffer);
private:
PPAGED_LOOKASIDE_LIST m_PagedLookasideList;
PNPAGED_LOOKASIDE_LIST m_NPagedLookasideList;
POOL_TYPE m_PoolType;
};
#endif
|
0cch
|
branches/noname/0.0.1.1/nm_mem.h
|
C++
|
lgpl
| 3,336
|
#include "nm_getproc.h"
PVOID kgetproc::FindExportedRoutineByName(PVOID DllBase, PANSI_STRING AnsiImageRoutineName )
{
USHORT OrdinalNumber;
PULONG NameTableBase;
PUSHORT NameOrdinalTableBase;
PULONG Addr;
LONG High;
LONG Low;
LONG Middle;
LONG Result;
ULONG ExportSize;
PVOID FunctionAddress;
PIMAGE_EXPORT_DIRECTORY ExportDirectory;
ExportDirectory = (PIMAGE_EXPORT_DIRECTORY) RtlImageDirectoryEntryToData (
DllBase,
TRUE,
IMAGE_DIRECTORY_ENTRY_EXPORT,
&ExportSize);
if (ExportDirectory == NULL) {
return NULL;
}
NameTableBase = (PULONG)((PCHAR)DllBase + (ULONG)ExportDirectory->AddressOfNames);
NameOrdinalTableBase = (PUSHORT)((PCHAR)DllBase + (ULONG)ExportDirectory->AddressOfNameOrdinals);
Low = 0;
Middle = 0;
High = ExportDirectory->NumberOfNames - 1;
while (High >= Low) {
Middle = (Low + High) >> 1;
Result = strcmp (AnsiImageRoutineName->Buffer,
(PCHAR)DllBase + NameTableBase[Middle]);
if (Result < 0) {
High = Middle - 1;
}
else if (Result > 0) {
Low = Middle + 1;
}
else {
break;
}
}
if (High < Low) {
return NULL;
}
OrdinalNumber = NameOrdinalTableBase[Middle];
if ((ULONG)OrdinalNumber >= ExportDirectory->NumberOfFunctions) {
return NULL;
}
Addr = (PULONG)((PCHAR)DllBase + (ULONG)ExportDirectory->AddressOfFunctions);
FunctionAddress = (PVOID)((PCHAR)DllBase + Addr[OrdinalNumber]);
return FunctionAddress;
}
PVOID kgetproc::GetSystemRoutineAddress(PUNICODE_STRING ModuleName, PUNICODE_STRING SystemRoutineName)
{
NTSTATUS Status;
PKLDR_DATA_TABLE_ENTRY DataTableEntry;
ANSI_STRING AnsiString;
PLIST_ENTRY NextEntry;
PVOID FunctionAddress;
const LARGE_INTEGER ShortTime = {(ULONG)(-10 * 1000 * 10), -1};
FunctionAddress = NULL;
do {
Status = RtlUnicodeStringToAnsiString (&AnsiString,
SystemRoutineName,
TRUE);
if (NT_SUCCESS (Status)) {
break;
}
KeDelayExecutionThread (KernelMode, FALSE, (PLARGE_INTEGER)&ShortTime);
} while (TRUE);
NextEntry = m_LoadedModuleList->Flink;
while (NextEntry != m_LoadedModuleList) {
DataTableEntry = CONTAINING_RECORD(NextEntry,
KLDR_DATA_TABLE_ENTRY,
InLoadOrderLinks);
if (DataTableEntry->BaseDllName.Buffer == NULL) {
NextEntry = NextEntry->Flink;
continue;
}
if (RtlEqualUnicodeString (ModuleName,
&DataTableEntry->BaseDllName,
TRUE)) {
FunctionAddress = FindExportedRoutineByName (DataTableEntry->DllBase,
&AnsiString);
break;
}
NextEntry = NextEntry->Flink;
}
RtlFreeAnsiString (&AnsiString);
return FunctionAddress;
}
|
0cch
|
branches/noname/0.0.1.1/nm_getproc.cpp
|
C++
|
lgpl
| 2,680
|
#ifndef __NONAME_HASHTABLE_H__
#define __NONAME_HASHTABLE_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#include "nm_mem.h"
#include "algo/crc32.h"
#define HASH_DEFAULT_CAP 128
template< class VAL >
class khashtable {
public:
BOOLEAN Init( ULONG Size = HASH_DEFAULT_CAP );
BOOLEAN Resize( ULONG Size = HASH_DEFAULT_CAP );
BOOLEAN Insert( PVOID KeyBuffer, ULONG Length, const VAL& Value );
BOOLEAN Remove( PVOID KeyBuffer, ULONG Length );
VAL* Find( PVOID KeyBuffer, ULONG Length );
void Clear();
ULONG GetHashTableSize() { return m_HashSize; }
ULONG GetHashedCount() { return m_HashedCount; }
ULONG GetConflictCount() { return m_ConflictCount; }
ULONG GetMaxConflictDepth() { return m_MaxConflictDepth; }
khashtable() { Init( HASH_DEFAULT_CAP ); }
void Release() { Clear(); }
private:
ULONG DoHash( PVOID KeyBuffer, ULONG Length );
struct _HASH_NODE {
/* is Value set ? */
BOOLEAN ValSet;
/* conflict link */
struct _HASH_NODE* Next;
/* conflicts may exist, so _Key is also needed */
PVOID Key;
VAL Value;
public:
_HASH_NODE() : ValSet( FALSE ), Next( NULL ), Key(NULL) {}
};
typedef struct _HASH_NODE HASH_NODE;
ULONG m_HashSize, m_HashedCount;
ULONG m_ConflictCount, m_MaxConflictDepth;
HASH_NODE m_HashTable;
};
template< class VAL >
ULONG khashtable<VAL>::DoHash( PVOID KeyBuffer, ULONG Length )
{
ULONG crc32;
crc32Init(&crc32);
crc32Update(&crc32, KeyBuffer, Length);
crc32Finish(&crc32);
return crc32 % m_HashSize;
}
template< class VAL >
BOOLEAN khashtable< VAL >::Init( ULONG Size /*= HASH_DEFAULT_CAP*/ )
{
if( m_HashTable != NULL ) {
return resize( Size );
}
m_HashTable = new HASH_NODE[ Size ];
m_ConflictCount = 0;
m_MaxConflictDepth = 0;
m_HashSize = Size;
m_HashedCount = 0,
return TRUE;
}
template< class VAL >
BOOLEAN khashtable< VAL >::Resize( ULONG Size /*= HASH_DEFAULT_CAP*/ )
{
if( Size == m_HashSize ) {
return TRUE;
}
if( m_HashTable != NULL ) {
Clear();
m_HashTable = NULL;
}
return Init( Size );
}
template< class VAL >
BOOLEAN khashtable< VAL >::Insert( PVOID KeyBuffer, ULONG Length, const VAL& Value )
{
ULONG key;
HASH_NODE *node;
ULONG depth;
HASH_NODE *pn;
if( m_HashTable == NULL ) {
return FALSE;
}
key = DoHash( KeyBuffer, Length );
if( !m_HashTable[ key ].ValSet ) {
m_HashTable[ key ].ValSet = TRUE;
m_HashTable[ key ].Key = new UCHAR[Length];
memcpy(m_HashTable[ key ].Key, KeyBuffer, Length);
m_HashTable[ key ].Value = Value;
return ++m_HashedCount, TRUE;
} else if( memcmp(m_HashTable[ key ].Key, KeyBuffer, Length) == 0) {
return TRUE;
}
/* walk thru the conflict list */
node = &m_HashTable[ key ];
for(depth = 1 ; node->Next != NULL; depth++ ) {
if( memcmp(node->Key, KeyBuffer, Length) == 0 ) {
return TRUE;
}
node = node->Next;
}
if( memcmp(node->Key, KeyBuffer, Length) == 0 ) {
return TRUE;
}
/* create conflict node */
pn = new HASH_NODE;
pn->Key = new UCHAR[Length];
memcpy(pn->Key, KeyBuffer, Length);
pn->Value = Value;
pn->ValSet = TRUE;
node->Next = pn;
#ifndef max
# define max(a,b) (((a) > (b)) ? (a) : (b))
#endif
m_ConflictCount++;
m_HashedCount++;
m_MaxConflictDepth = max( m_MaxConflictDepth, depth );
return TRUE;
}
template< class VAL >
BOOLEAN khashtable< VAL >::Remove( PVOID KeyBuffer, ULONG Length )
{
ULONG key;
HASH_NODE *tmp;
HASH_NODE *node;
HASH_NODE *nxt;
if( m_HashTable == NULL ) {
return FALSE;
}
key = DoHash( KeyBuffer, Length );
if( m_HashTable[ key ].ValSet && memcmp(m_HashTable[ key ].Key, KeyBuffer, Length) == 0 ) {
m_HashedCount--;
if (m_HashTable[ key ].Key != NULL) {
delete m_HashTable[ key ].Key;
m_HashTable[ key ].Key = NULL;
}
tmp = m_HashTable[ key ].Next;
if( tmp == NULL) {
m_HashTable[ key ].Value = 0; /* this may destruct some instance */
m_HashTable[ key ].ValSet = FALSE;
return TRUE;
}
m_HashTable[ key ].Key = tmp->Key;
m_HashTable[ key ].Value = tmp->Value;
m_HashTable[ key ].Next = tmp->Next;
delete tmp;
return TRUE;
}
node = &m_HashTable[ key ];
while( node->Next != NULL ) {
nxt = node->Next;
if( nxt->ValSet && memcmp(nxt->Key, KeyBuffer, Length) == 0 ) {
m_HashedCount--;
node->Next = nxt->Next;
if (nxt->Key != NULL) {
delete nxt->Key;
}
delete nxt;
return TRUE;
}
node = nxt;
}
return FALSE;
}
template< class VAL >
VAL* khashtable< VAL >::Find( PVOID KeyBuffer, ULONG Length )
{
ULONG key;
HASH_NODE *node ;
if( m_HashTable == NULL ) {
return FALSE;
}
key = DoHash( KeyBuffer, Length );
node = &m_HashTable[ key ];
do {
if( node->ValSet && memcmp(node->Key, KeyBuffer, Length) == 0 ) {
return &node->Value;
}
node = node->Next;
} while( node != NULL );
return NULL;
}
template< class VAL >
void khashtable< VAL >::Clear()
{
ULONG i;
HASH_NODE *node;
HASH_NODE* tmp;
if( m_HashTable == NULL )
return ;
for( i = 0; i < m_HashSize; i++ ) {
if (m_HashTable[i].ValSet && m_HashTable[i].Key != NULL) {
delete m_HashTable[i].Key;
m_HashTable[i].Key = NULL;
}
m_HashTable[i].ValSet = FALSE;
node = m_HashTable[i].Next;
while( node != NULL) {
tmp = node;
node = node->Next;
if (tmp->ValSet && tmp->Key != NULL) {
delete tmp->Key;
}
delete tmp;
}
}
delete[] m_HashTable;
m_HashTable = NULL;
m_HashedCount = 0;
m_ConflictCount = 0;
m_MaxConflictDepth = 0;
}
#endif
|
0cch
|
branches/noname/0.0.1.1/nm_hashtable.h
|
C++
|
lgpl
| 5,700
|
#ifndef __NONAME_FILE_H__
#define __NONAME_FILE_H__
#define NONAME_LIB_USE
#include <Ntifs.h>
#include "nm_mem.h"
#include "nm_string.h"
#define FILE_BEGIN 0
#define FILE_CURRENT 1
#define FILE_END 2
class kfile {
public:
kfile();
void Release();
VOID Close();
NTSTATUS Create(
kstringw& FileName,
ULONG CreateDisposition = FILE_OPEN,
ACCESS_MASK DesiredAccess = GENERIC_READ,
ULONG ShareAccess = FILE_SHARE_READ
);
NTSTATUS Create(
PWCHAR FileName,
ULONG CreateDisposition = FILE_OPEN,
ACCESS_MASK DesiredAccess = GENERIC_READ,
ULONG ShareAccess = FILE_SHARE_READ
);
NTSTATUS Create(
PUNICODE_STRING FileName,
ULONG CreateDisposition = FILE_OPEN,
ACCESS_MASK DesiredAccess = GENERIC_READ,
ULONG ShareAccess = FILE_SHARE_READ
);
NTSTATUS Delete(BOOLEAN Del = TRUE);
NTSTATUS Flush();
HANDLE GetHandle();
NTSTATUS GetName(kstringw& String);
PFILE_OBJECT GetObject();
NTSTATUS GetPath(kstringw& String);
NTSTATUS GetPath(PFILE_NAME_INFORMATION NameInfo, ULONG Length);
NTSTATUS GetSize(PLARGE_INTEGER FileSize);
NTSTATUS Read(PVOID Buffer, ULONG Length, PULONG RetLength = NULL);
NTSTATUS Rename(PFILE_RENAME_INFORMATION RenameInfo, ULONG Length);
NTSTATUS Rename(kstringw& Name, BOOLEAN ReplaceIfExists = FALSE);
BOOLEAN SetPointer(PLARGE_INTEGER DistanceToMove, ULONG Flag = FILE_BEGIN, PLARGE_INTEGER NewPointer = NULL);
NTSTATUS SetEnd(PLARGE_INTEGER EndPos);
NTSTATUS Write(PVOID Buffer, ULONG Length, PULONG RetLength = NULL);
private:
HANDLE m_filehandle;
PFILE_OBJECT m_fileobj;
};
#endif
|
0cch
|
branches/noname/0.0.1.1/nm_file.h
|
C++
|
lgpl
| 1,629
|
#include "nm_dir.h"
kdirectory::kdirectory()
{
m_filehandle = 0;
m_fileobj = NULL;
}
void kdirectory::Release()
{
Close();
}
VOID kdirectory::Close()
{
if (m_fileobj != NULL) {
ObDereferenceObject(m_fileobj);
m_fileobj = NULL;
}
if (m_filehandle != NULL) {
ZwClose(m_filehandle);
m_filehandle = 0;
}
}
NTSTATUS kdirectory::Create( PWCHAR FileName, ULONG CreateDisposition /*= FILE_OPEN*/, ACCESS_MASK DesiredAccess /*= GENERIC_READ*/, ULONG ShareAccess /*= FILE_SHARE_READ */ )
{
UNICODE_STRING Name;
RtlInitUnicodeString(&Name, FileName);
return Create(&Name, CreateDisposition, DesiredAccess, ShareAccess);
}
NTSTATUS kdirectory::Create( PUNICODE_STRING FileName, ULONG CreateDisposition /*= FILE_OPEN*/, ACCESS_MASK DesiredAccess /*= GENERIC_READ*/, ULONG ShareAccess /*= FILE_SHARE_READ */ )
{
NTSTATUS ns;
OBJECT_ATTRIBUTES oa;
IO_STATUS_BLOCK Iob;
Close();
InitializeObjectAttributes(&oa, FileName, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, 0, NULL);
ns = IoCreateFile(&m_filehandle,
DesiredAccess | SYNCHRONIZE,
&oa,
&Iob,
NULL,
FILE_ATTRIBUTE_NORMAL,
ShareAccess,
CreateDisposition,
FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
NULL,
0,
CreateFileTypeNone,
NULL,
IO_NO_PARAMETER_CHECKING);
if (!NT_SUCCESS(ns)) {
return ns;
}
ns = ObReferenceObjectByHandle(m_filehandle, 0, *IoFileObjectType, KernelMode, (PVOID *)&m_fileobj, NULL);
if (!NT_SUCCESS(ns)) {
ZwClose(m_filehandle);
m_filehandle = 0;
}
return ns;
}
NTSTATUS kdirectory::Create( kstringw& FileName, ULONG CreateDisposition /*= FILE_OPEN*/, ACCESS_MASK DesiredAccess /*= GENERIC_READ*/, ULONG ShareAccess /*= FILE_SHARE_READ */ )
{
return Create((PUNICODE_STRING)FileName, CreateDisposition, DesiredAccess, ShareAccess);
}
NTSTATUS kdirectory::Delete( BOOLEAN Del /*= TRUE*/ )
{
NTSTATUS ns;
IO_STATUS_BLOCK Iob;
FILE_DISPOSITION_INFORMATION FileDispInfo;
FileDispInfo.DeleteFile = Del;
ns = ZwSetInformationFile(m_filehandle,
&Iob,
&FileDispInfo,
sizeof(FileDispInfo),
FileDispositionInformation);
return ns;
}
HANDLE kdirectory::GetHandle()
{
return m_filehandle;
}
NTSTATUS kdirectory::GetName(kstringw& String)
{
kstringw Path;
NTSTATUS ns;
INT Pos;
ULONG RightCch;
ns = GetPath(Path);
if (!NT_SUCCESS(ns)) {
return ns;
}
Pos = Path.ReverseFind(L'\\');
if (Pos == -1) {
return STATUS_UNSUCCESSFUL;
}
Pos++;
RightCch = Path.GetLength() - Pos;
Path.Right(RightCch);
return ns;
}
PFILE_OBJECT kdirectory::GetObject()
{
return m_fileobj;
}
NTSTATUS kdirectory::GetPath(kstringw& String)
{
PUCHAR Buffer;
kstringw Path;
NTSTATUS ns;
Buffer = new UCHAR[1024];
RtlZeroMemory(Buffer, 1024);
ns = GetPath((PFILE_NAME_INFORMATION)Buffer, 1024 - sizeof(WCHAR));
if (!NT_SUCCESS(ns)) {
delete[] Buffer;
return ns;
}
String.Copy(((PFILE_NAME_INFORMATION)Buffer)->FileName,
((PFILE_NAME_INFORMATION)Buffer)->FileNameLength / sizeof(WCHAR));
delete[] Buffer;
return ns;
}
NTSTATUS kdirectory::GetPath( PFILE_NAME_INFORMATION NameInfo, ULONG Length)
{
NTSTATUS ns;
IO_STATUS_BLOCK Iob;
return ZwQueryInformationFile(m_filehandle,
&Iob,
&NameInfo,
Length,
FileNameInformation);
}
NTSTATUS kdirectory::MakeDir( PUNICODE_STRING FileName )
{
NTSTATUS ns;
PWCHAR p = FileName->Buffer;
USHORT i = 0;
PWCHAR q;
kstringw dir;
ns = Create(FileName, FILE_OPEN_IF, GENERIC_READ | GENERIC_WRITE);
if (NT_SUCCESS(ns)) {
Close();
return ns;
}
q = dir.Allocate(FileName->Length / sizeof(WCHAR));
while (i < FileName->Length) {
if (L'\\' == *p) {
if (L':' != *(p - 1)) {
Create(dir.GetUnicodeString(), FILE_OPEN_IF, GENERIC_READ | GENERIC_WRITE);
}
}
*q++ = *p++;
*q = L'\0';
i += 2;
}
ns = Create(dir.GetUnicodeString(), FILE_OPEN_IF, GENERIC_READ | GENERIC_WRITE);
Close();
return ns;
}
NTSTATUS kdirectory::MakeDir( kstringw& FileName )
{
return MakeDir(FileName.GetUnicodeString());
}
NTSTATUS kdirectory::MakeDir( PWCHAR FileName )
{
UNICODE_STRING UniString;
RtlInitUnicodeString(&UniString, FileName);
return MakeDir(&UniString);
}
NTSTATUS kdirectory::Rename( PFILE_RENAME_INFORMATION RenameInfo, ULONG Length )
{
IO_STATUS_BLOCK Iob;
return ZwSetInformationFile(m_filehandle,
&Iob,
RenameInfo,
Length,
FileRenameInformation);
}
NTSTATUS kdirectory::Rename( kstringw& Name, BOOLEAN ReplaceIfExists )
{
NTSTATUS ns;
PUCHAR Buffer;
PFILE_RENAME_INFORMATION RenameInfo;
Buffer = new UCHAR[1024];
RtlZeroMemory(Buffer, 1024);
RenameInfo = (PFILE_RENAME_INFORMATION)Buffer;
RenameInfo->ReplaceIfExists = ReplaceIfExists;
RenameInfo->RootDirectory = NULL;
RenameInfo->FileNameLength = Name.GetLength() * sizeof(WCHAR);
RtlStringCbCopyW(RenameInfo->FileName, 1024 - sizeof(FILE_RENAME_INFORMATION), Name.GetString());
ns = Rename(RenameInfo, 1024);
delete[] Buffer;
return ns;
}
NTSTATUS kdirectory::QueryDir(
PVOID FileInformation,
ULONG Length,
PUNICODE_STRING FileName /*= NULL*/,
FILE_INFORMATION_CLASS FileInformationClass /*= FileBothDirectoryInformation*/,
BOOLEAN ReturnSingleEntry /*= TRUE */
)
{
IO_STATUS_BLOCK Iob;
return ZwQueryDirectoryFile(m_filehandle,
NULL,
NULL,
NULL,
&Iob,
FileInformation,
Length,
FileInformationClass,
ReturnSingleEntry,
FileName,
FALSE);
}
BOOLEAN kdirectory::IsDirectory( kstringw& String )
{
return kdirectory::IsDirectory(String.GetUnicodeString());
}
BOOLEAN kdirectory::IsDirectory( PUNICODE_STRING UniString )
{
NTSTATUS ns;
OBJECT_ATTRIBUTES oa;
IO_STATUS_BLOCK Iob;
HANDLE FileHandle;
FILE_STANDARD_INFORMATION FileInfo;
InitializeObjectAttributes(&oa, UniString, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, 0, NULL);
ns = IoCreateFile(&FileHandle,
GENERIC_READ,
&oa,
&Iob,
NULL,
FILE_ATTRIBUTE_NORMAL,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
FILE_OPEN,
FILE_SYNCHRONOUS_IO_NONALERT,
NULL,
0,
CreateFileTypeNone,
NULL,
IO_NO_PARAMETER_CHECKING);
if (!NT_SUCCESS(ns)) {
return FALSE;
}
ns = ZwQueryInformationFile(FileHandle, &Iob, &FileInfo, sizeof(FileInfo), FileStandardInformation);
ZwClose(FileHandle);
if (!NT_SUCCESS(ns)) {
return FALSE;
}
return FileInfo.Directory;
}
BOOLEAN kdirectory::IsDirectory( PWCHAR String )
{
UNICODE_STRING UniString;
RtlInitUnicodeString(&UniString, String);
return kdirectory::IsDirectory(&UniString);
}
|
0cch
|
branches/noname/0.0.1.1/nm_dir.cpp
|
C++
|
lgpl
| 6,813
|
#ifndef __NONAME_INLINE_HOOK_H__
#define __NONAME_INLINE_HOOK_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#include "nm_mem.h"
#include "disasm/LDasm.h"
typedef BOOLEAN (__stdcall *HOOKPROC)(PVOID Context);
typedef struct _DPCLOCK_CONTEXT {
PKDPC Dpcs;
LONG Locks;
BOOLEAN Release;
_DPCLOCK_CONTEXT() : Dpcs(NULL), Locks(0), Release(FALSE) {}
} DPCLOCK_CONTEXT, *PDPCLOCK_CONTEXT;
class kinlinehook {
public:
kinlinehook() {}
static BOOLEAN AutoHook(PVOID Dst, PVOID Src, PVOID *Proxy);
static BOOLEAN Hook(HOOKPROC HookProc, PVOID Context);
static VOID __stdcall DpcLock(struct _KDPC *Dpc, PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2);
static VOID WPOFF();
static VOID WPON();
};
__forceinline
VOID kinlinehook::WPOFF()
{
__asm {
cli
mov eax, cr0
and eax, 0fffeffffh
mov cr0, eax
}
}
__forceinline
VOID kinlinehook::WPON()
{
__asm {
mov eax, cr0
or eax, 10000h
mov cr0, eax
sti
}
}
#endif
|
0cch
|
branches/noname/0.0.1.1/nm_inlinehook.h
|
C++
|
lgpl
| 1,040
|
#ifndef __NONAME_UNDOCUMENT_H__
#define __NONAME_UNDOCUMENT_H__
#include <ntifs.h>
#define IMAGE_DIRECTORY_ENTRY_EXPORT 0
typedef struct _IMAGE_EXPORT_DIRECTORY {
ULONG Characteristics;
ULONG TimeDateStamp;
USHORT MajorVersion;
USHORT MinorVersion;
ULONG Name;
ULONG Base;
ULONG NumberOfFunctions;
ULONG NumberOfNames;
ULONG AddressOfFunctions; // RVA from base of image
ULONG AddressOfNames; // RVA from base of image
ULONG AddressOfNameOrdinals; // RVA from base of image
} IMAGE_EXPORT_DIRECTORY, *PIMAGE_EXPORT_DIRECTORY;
typedef struct _NON_PAGED_DEBUG_INFO {
USHORT Signature;
USHORT Flags;
ULONG Size;
USHORT Machine;
USHORT Characteristics;
ULONG TimeDateStamp;
ULONG CheckSum;
ULONG SizeOfImage;
ULONGLONG ImageBase;
} NON_PAGED_DEBUG_INFO, *PNON_PAGED_DEBUG_INFO;
typedef struct _KLDR_DATA_TABLE_ENTRY {
LIST_ENTRY InLoadOrderLinks;
PVOID ExceptionTable;
ULONG ExceptionTableSize;
// ULONG padding on IA64
PVOID GpValue;
PNON_PAGED_DEBUG_INFO NonPagedDebugInfo;
PVOID DllBase;
PVOID EntryPoint;
ULONG SizeOfImage;
UNICODE_STRING FullDllName;
UNICODE_STRING BaseDllName;
ULONG Flags;
USHORT LoadCount;
USHORT __Unused5;
PVOID SectionPointer;
ULONG CheckSum;
// ULONG padding on IA64
PVOID LoadedImports;
PVOID PatchInformation;
} KLDR_DATA_TABLE_ENTRY, *PKLDR_DATA_TABLE_ENTRY;
#ifdef __cplusplus
extern "C" {
#endif
NTKERNELAPI
NTSTATUS
KeSetAffinityThread(
PKTHREAD Thread,
KAFFINITY Affinity
);
NTKERNELAPI
PVOID
RtlImageDirectoryEntryToData (
IN PVOID Base,
IN BOOLEAN MappedAsImage,
IN USHORT DirectoryEntry,
OUT PULONG Size
);
#ifdef __cplusplus
};
#endif
#endif
|
0cch
|
branches/noname/0.0.1.1/nm_undoc.h
|
C
|
lgpl
| 1,795
|
#ifndef __NONAME_VECTOR_H__
#define __NONAME_VECTOR_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#include "nm_mem.h"
#define DEFAULT_INIT_VECTOR 32
template <class T>
class kvector {
public:
kvector();
kvector(ULONG Size, ULONG Step);
void Release();
ULONG Size() { return m_ItemCount; }
T& operator[] (ULONG Index);
private:
T *m_Vector;
ULONG m_ItemCount;
ULONG m_Step;
};
template <class T>
kvector<T>::kvector()
{
m_Step = DEFAULT_INIT_VECTOR;
m_ItemCount = DEFAULT_INIT_VECTOR;
m_Vector = new T[m_ItemCount];
}
template <class T>
T& kvector<T>::operator[]( ULONG Index )
{
ULONG Count;
T *tmp;
ULONG i;
if (Index >= m_ItemCount) {
Count = m_ItemCount;
while (Index >= Count) {
Count += m_Step;
}
tmp = new T[Count];
for (i = 0; i < m_ItemCount; i++){
tmp[i] = m_Vector[i];
}
m_ItemCount = Count;
delete[] m_Vector;
m_Vector = tmp;
}
return m_Vector[Index];
}
template <class T>
void kvector<T>::Release()
{
delete[] m_Vector;
}
template <class T>
kvector<T>::kvector( ULONG Size, ULONG Step )
{
m_Step = Step;
m_ItemCount = Size;
m_Vector = new T[m_ItemCount];
}
#endif
|
0cch
|
branches/noname/0.0.1.1/nm_vector.h
|
C++
|
lgpl
| 1,229
|
#include "nm_string.h"
kstringw::kstringw()
{
m_stringw = NULL;
m_len = 0;
}
kstringw::kstringw( PWCHAR String )
{
ULONG Size;
Size = wcslen(String);
m_stringw = Allocate(Size, FALSE);
RtlStringCchCopyW(m_stringw, Size, String);
m_len = Size;
}
kstringw::kstringw( PUNICODE_STRING UniString )
{
ULONG Size;
Size = (ULONG)UniString->MaximumLength;
m_stringw = Allocate(Size, FALSE);
RtlStringCchCopyNW(m_stringw, Size, UniString->Buffer, UniString->Length / sizeof(WCHAR));
m_len = Size;
}
void kstringw::Release()
{
if (m_stringw != NULL) {
delete[] m_stringw;
}
m_len = 0;
}
PWCHAR kstringw::Allocate(ULONG Size, BOOLEAN SaveData)
{
PWCHAR buf;
if (0 == Size) {
Size = 1;
}
if (m_len < Size) {
m_len = Size;
buf = new WCHAR[m_len + 1];
RtlZeroMemory(m_stringw, (m_len + 1) * sizeof(WCHAR));
if (SaveData) {
if (NULL != m_stringw) {
RtlStringCchCopyW(buf, Size, m_stringw);
}
}
if (NULL != m_stringw) {
delete[] m_stringw;
}
m_stringw = buf;
}
if (!SaveData) {
RtlZeroMemory(m_stringw, (m_len + 1) * sizeof(WCHAR));
}
return m_stringw;
}
void kstringw::Append( WCHAR ch )
{
DWORD len;
PWCHAR buf;
len = wcslen(m_stringw);
buf = Allocate(len + 1, TRUE);
buf[len] = ch;
buf[len + 1] = L'\0';
}
void kstringw::Attach( PWCHAR String )
{
if (NULL != m_stringw) {
delete[] m_stringw;
}
m_stringw = String;
m_len = wcslen(String);
}
int kstringw::Compare( PWCHAR String, BOOLEAN CaseInsensitive )
{
if (CaseInsensitive) {
return _wcsicmp(m_stringw, String);
}
else {
return wcscmp(m_stringw, String);
}
}
void kstringw::Copy( PWCHAR String, ULONG Cch )
{
ULONG len;
PWCHAR p;
if (Cch == 0) {
len = wcslen(String);
}
else {
len = Cch;
}
p = Allocate(len, FALSE);
if (0 == m_len) {
Empty();
}
else {
RtlStringCchCopyNW(p, len, String, len);
}
}
PWCHAR kstringw::Detach()
{
PWCHAR ret = m_stringw;
m_stringw = NULL;
m_len = 0;
return ret;
}
void kstringw::Empty()
{
if (NULL == m_stringw) {
m_stringw = Allocate(1, FALSE);
}
m_stringw[0] = L'\0';
}
INT kstringw::Find( WCHAR ch, INT Start )
{
PWCHAR p;
if (NULL == m_stringw || (INT)wcslen(m_stringw) < Start) {
return -1;
}
p = wcschr(m_stringw + Start, ch);
if (NULL == p) {
return -1;
}
return (INT)(p - m_stringw);
}
INT kstringw::Find( PWCHAR String, INT Start )
{
PWCHAR p;
if (NULL == m_stringw || (INT)wcslen(m_stringw) < Start) {
return -1;
}
p = wcsstr(m_stringw + Start, String);
if (NULL == p) {
return -1;
}
return (INT)(p - m_stringw);
}
INT kstringw::Format( __in PWCHAR Formats, ... )
{
WCHAR tmp[1024];
va_list argList;
INT ret;
va_start(argList, Formats);
ret = RtlStringCbPrintfW(tmp, 1024, Formats, argList);
va_end(argList);
Copy(tmp);
return ret;
}
WCHAR kstringw::GetAt( __in ULONG idx )
{
if (idx > (wcslen(m_stringw) - 1)) {
idx = wcslen(m_stringw);
}
return m_stringw[idx];
}
INT kstringw::GetLength() const
{
return wcslen(m_stringw);
}
PWCHAR kstringw::GetString() const
{
return m_stringw;
}
PUNICODE_STRING kstringw::GetUnicodeString()
{
RtlInitUnicodeString(&m_UniString, m_stringw);
return &m_UniString;
}
BOOLEAN kstringw::IsEmpty() const
{
return (NULL == m_stringw || L'\0' == *m_stringw);
}
void kstringw::Left( ULONG Cch )
{
if (Cch < wcslen(m_stringw)) {
m_stringw[Cch] = L'\0';
}
}
void kstringw::Mid( ULONG Start, ULONG Cch )
{
PWCHAR buf;
buf = new WCHAR[Cch + 1];
RtlZeroMemory(buf, (Cch + 1) * sizeof(WCHAR));
RtlStringCchCopyNW(buf, Cch, m_stringw + Start, Cch);
Copy(buf);
delete[] buf;
}
void kstringw::MakeUpper()
{
_wcsupr(m_stringw);
}
void kstringw::MakeLower()
{
_wcslwr(m_stringw);
}
void kstringw::Right( ULONG Cch )
{
PWCHAR buf;
buf = new WCHAR[Cch + 1];
RtlZeroMemory(buf, (Cch + 1) * sizeof(WCHAR));
RtlStringCchCopyNW(buf, Cch, m_stringw + wcslen(m_stringw) - Cch, Cch);
Copy(buf);
delete[] buf;
}
INT kstringw::Replace( PWCHAR Old, PWCHAR New )
{
ULONG StrLen = wcslen(m_stringw);
ULONG OldLen = wcslen(Old);
ULONG NewLen = wcslen(New);
INT cnt = 0;
PWCHAR Start = m_stringw;
PWCHAR End = m_stringw + OldLen;
PWCHAR Target;
PWCHAR NewBuf;
PWCHAR dst;
PWCHAR src;
PWCHAR p = NULL;
INT CchCopy = 0;
INT tmp;
INT i;
if (0 == StrLen) {
return 0;
}
if (0 == OldLen) {
return 0;
}
while (Start < End) {
while ((Target = wcsstr(Start, Old)) != NULL) {
cnt++;
Start = Target + OldLen;
}
if (NULL == Target) {
break;
}
}
if (0 == cnt) {
return 0;
}
StrLen += (NewLen - OldLen) * cnt;
NewBuf = new WCHAR[StrLen];
RtlZeroMemory(NewBuf, StrLen * sizeof(WCHAR));
dst = NewBuf;
src = m_stringw;
tmp = StrLen;
for (i = 0; i < cnt; i++) {
p = wcsstr(src, Old);
CchCopy = p - src;
RtlStringCchCopyNW(dst, tmp, src, CchCopy);
dst += CchCopy;
tmp -= CchCopy;
src = p;
RtlStringCchCopyNW(dst, tmp, New, NewLen);
dst += NewLen;
tmp -= NewLen;
src += OldLen;
}
RtlStringCchCopyW(dst, tmp, src);
delete[] m_stringw;
m_stringw = NewBuf;
m_len = StrLen;
return cnt;
}
INT kstringw::ReverseFind( WCHAR ch )
{
PWCHAR p = wcsrchr(m_stringw, ch);
if (NULL == p)
return -1;
return p - m_stringw;
}
WCHAR kstringw::SetAt( ULONG pos, WCHAR ch )
{
ULONG len;
WCHAR ret;
if (NULL == m_stringw || L'\0' == *m_stringw)
return -1;
len = wcslen(m_stringw);
if (pos >= len) {
pos = len - 1;
}
ret = m_stringw[pos];
m_stringw[pos] = ch;
return ret;
}
kstringw::operator PWCHAR() const
{
return m_stringw;
}
kstringw::operator PUNICODE_STRING()
{
RtlInitUnicodeString(&m_UniString, m_stringw);
return &m_UniString;
}
kstringw& kstringw::operator=( PWCHAR String )
{
Copy(String);
return *this;
}
kstringw& kstringw::operator=( PUNICODE_STRING UniString )
{
Copy(UniString->Buffer, UniString->Length / sizeof(WCHAR));
return *this;
}
kstringw& kstringw::operator=( const kstringw& str )
{
if (this != &str)
Copy((PWCHAR)str);
return *this;
}
BOOLEAN kstringw::operator==( kstringw& str2 )
{
if (this->Compare(str2.GetString()) == 0) {
return TRUE;
}
return FALSE;
}
BOOLEAN kstringw::operator==( PWCHAR str2 )
{
if (this->Compare(str2) == 0) {
return TRUE;
}
return FALSE;
}
const kstringw& kstringw::operator+=( PUNICODE_STRING UniString )
{
ULONG Len = GetLength();
Allocate(Len + UniString->Length / sizeof(WCHAR), TRUE);
RtlStringCchCopyNW(&m_stringw[Len], UniString->Length / sizeof(WCHAR), UniString->Buffer, UniString->Length / sizeof(WCHAR));
return *this;
}
const kstringw& kstringw::operator+=( PWCHAR String )
{
ULONG Len = GetLength();
Allocate(Len + wcslen(String), TRUE);
RtlStringCchCopyW(&m_stringw[Len], wcslen(String), String);
return *this;
}
const kstringw& kstringw::operator+=( WCHAR ch )
{
Append(ch);
return *this;
}
const kstringw& kstringw::operator+=( const kstringw& str )
{
ULONG Len = GetLength();
Allocate(Len + str.GetLength(), TRUE);
RtlStringCchCopyW(&m_stringw[Len], str.GetLength(), (PWCHAR)str);
return *this;
}
WCHAR kstringw::operator[]( ULONG idx )
{
return GetAt(idx);
}
|
0cch
|
branches/noname/0.0.1.1/nm_string.cpp
|
C++
|
lgpl
| 7,554
|
#ifndef __NONAME_DIR_H__
#define __NONAME_DIR_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#include "nm_mem.h"
#include "nm_string.h"
class kdirectory {
public:
kdirectory();
void Release();
VOID Close();
NTSTATUS Create(
kstringw& FileName,
ULONG CreateDisposition = FILE_OPEN,
ACCESS_MASK DesiredAccess = GENERIC_READ,
ULONG ShareAccess = FILE_SHARE_READ
);
NTSTATUS Create(
PWCHAR FileName,
ULONG CreateDisposition = FILE_OPEN,
ACCESS_MASK DesiredAccess = GENERIC_READ,
ULONG ShareAccess = FILE_SHARE_READ
);
NTSTATUS Create(
PUNICODE_STRING FileName,
ULONG CreateDisposition = FILE_OPEN,
ACCESS_MASK DesiredAccess = GENERIC_READ,
ULONG ShareAccess = FILE_SHARE_READ
);
NTSTATUS Delete(BOOLEAN Del = TRUE);
HANDLE GetHandle();
NTSTATUS GetName(kstringw& String);
PFILE_OBJECT GetObject();
NTSTATUS GetPath(kstringw& String);
NTSTATUS GetPath(PFILE_NAME_INFORMATION NameInfo, ULONG Length);
NTSTATUS MakeDir(PUNICODE_STRING FileName);
NTSTATUS MakeDir(kstringw& FileName);
NTSTATUS MakeDir(PWCHAR FileName);
NTSTATUS QueryDir(
PVOID FileInformation,
ULONG Length,
PUNICODE_STRING FileName = NULL,
FILE_INFORMATION_CLASS FileInformationClass = FileBothDirectoryInformation,
BOOLEAN ReturnSingleEntry = TRUE
);
NTSTATUS Rename(PFILE_RENAME_INFORMATION RenameInfo, ULONG Length);
NTSTATUS Rename(kstringw& Name, BOOLEAN ReplaceIfExists = FALSE);
static BOOLEAN IsDirectory(kstringw& String);
static BOOLEAN IsDirectory(PUNICODE_STRING UniString);
static BOOLEAN IsDirectory(PWCHAR String);
private:
HANDLE m_filehandle;
PFILE_OBJECT m_fileobj;
};
#endif
|
0cch
|
branches/noname/0.0.1.1/nm_dir.h
|
C++
|
lgpl
| 1,705
|
#ifndef __SECTOR_MON_H__
#define __SECTOR_MON_H__
#include <ntifs.h>
#include <Ntddvol.h>
#define DEVICE_TYPE_CTRL 0
#define DEVICE_TYPE_FILTER 1
typedef struct _DISK_FLT_DEVICE_EXT {
ULONG DeviceType;
PDEVICE_OBJECT FilterDeviceObject;
PDEVICE_OBJECT LowerDeviceObject;
PDEVICE_OBJECT PhysicalDeviceObject;
LIST_ENTRY ReqList;
KSPIN_LOCK ReqLock;
KEVENT ReqEvent;
BOOLEAN ThreadFlag;
PETHREAD ThreadObject;
PAGED_LOOKASIDE_LIST WriteElemHeader;
PAGED_LOOKASIDE_LIST SectorBufHeader;
} DISK_FLT_DEVICE_EXT, *PDISK_FLT_DEVICE_EXT;
typedef struct _WRITE_ELEMENT {
LIST_ENTRY ListEntry;
HANDLE File;
PVOID Buffer;
ULONG Length;
LARGE_INTEGER Offset;
BOOLEAN NeedFree;
ULONG Tag;
} WRITE_ELEMENT, *PWRITE_ELEMENT;
typedef struct _GLOBAL_CONTEXT {
HANDLE FileHandle;
PVOID MapBuffer;
ULONG MapSize;
HANDLE SparseFileHandle;
} GLOBAL_CONTEXT, *PGLOBAL_CONTEXT;
#pragma pack(push, 1)
typedef struct _NTFS_BPB {
USHORT BytesPerSector;
UCHAR SectorsPerCluster;
USHORT ReservedSectors;
UCHAR NumberOfFATs; // always 0
USHORT RootEntries; // always 0
USHORT SmallSectors; // not used by NTFS
UCHAR MediaDescriptor;
USHORT SectorsPerFAT; // always 0
USHORT SectorsPerTrack;
USHORT NumberOfHeads;
ULONG HiddenSectors;
ULONG LargeSectors; // not used by NTFS
} NTFS_BPB, *PNTFS_BPB;
typedef struct _NTFS_EXBPB { // Extended BIOS parameter block for FAT16
ULONG Reserved; // not used by NTFS
ULONGLONG TotalSectors;
ULONGLONG MFT;
ULONGLONG MFTMirr;
ULONG ClustersPerFileRecordSegment;
ULONG ClustersPerIndexBlock;
ULONGLONG VolumeSerialNumber;
ULONG Checksum;
} NTFS_EXBPB, *PNTFS_EXBPB;
typedef struct _NTFS_BOOT_SEC {
UCHAR JumpInstruction[3];
UCHAR OemID[8];
NTFS_BPB Bpb;
NTFS_EXBPB ExBpb;
UCHAR BootstrapCode[426];
UCHAR EndOfSector[2];
} NTFS_BOOT_SEC, *PNTFS_BOOT_SEC;
#pragma pack(pop)
#define DIRECT_READ 0
#define DIRECT_WRITE 1
#define BITOFF_TO_MAPOFF(off) (ULONG)(off >> 3)
#define BITLEN_TO_MAPLEN(off, len) ((ULONG)((off + len) >> 3) - BITOFF_TO_MAPOFF(off) + 1)
#define BYTEOFF_TO_BITOFF(off) (off / BytesPerSector)
#define BYTELEN_TO_BITLEN(len) (len / BytesPerSector)
NTSTATUS SkipAndCallDriver( __in PDEVICE_OBJECT DeviceObject, __in PIRP Irp );
NTSTATUS SyncIrpCompletionRoutine( __in PDEVICE_OBJECT DeviceObject, __in PIRP Irp, __in PVOID Context );
NTSTATUS SendSyncIrp( __in PDEVICE_OBJECT DeviceObject, __in PIRP Irp );
NTSTATUS DispatchPassThrough( __in PDEVICE_OBJECT DeviceObject, __in PIRP Irp );
NTSTATUS DispatchPower( __in PDEVICE_OBJECT DeviceObject, __in PIRP Irp );
NTSTATUS DispatchPnp( __in PDEVICE_OBJECT DeviceObject, __in PIRP Irp );
NTSTATUS DispatchReadWrite( __in PDEVICE_OBJECT DeviceObject, __in PIRP Irp );
NTSTATUS DispatchDeviceControl( __in PDEVICE_OBJECT DeviceObject, __in PIRP Irp );
NTSTATUS DirectReadWrite( __in PDEVICE_OBJECT DeviceObject, __in ULONG ReadWrite, __out PVOID Buffer, __in PLARGE_INTEGER Offset, __in ULONG Length );
LONGLONG GetFileSize( __in HANDLE Handle );
BOOLEAN __fastcall SetBit( __in PUCHAR BitBuf, __in ULONG BitSize, __in ULONGLONG Bit );
BOOLEAN __fastcall ClearBit( __in PUCHAR BitBuf, __in ULONG BitSize, __in ULONGLONG Bit );
ULONG __fastcall GetBit( __in PUCHAR BitBuf, __in ULONG BitSize, __in ULONGLONG Bit );
NTSTATUS OpenMapping( __in PWCHAR Name, __out PHANDLE File, __out PVOID *Buffer, __out ULONG *BufferSize );
VOID CloseMapping( __in HANDLE File, __in PVOID Buffer );
NTSTATUS CreateSparseFile( __out PHANDLE Handle, __in PWCHAR FileName, __in ULONGLONG FileSize, __in BOOLEAN Restore );
NTSTATUS AddDevice( __in PDRIVER_OBJECT DriverObject, __in PDEVICE_OBJECT PhysicalDeviceObject );
VOID Unload( __in PDRIVER_OBJECT DriverObject );
VOID ReinitializationRoutine( __in PDRIVER_OBJECT DriverObject, __in PVOID Context, __in ULONG Count );
NTSTATUS DriverEntry( __in PDRIVER_OBJECT DriverObject, __in PUNICODE_STRING RegistryPath );
NTSTATUS FlushBuffer( __in PDISK_FLT_DEVICE_EXT DevExt, __in HANDLE File, __in PVOID Buffer, __in ULONG Offset, __in ULONG Size );
NTSTATUS __fastcall BackupSectorAndSetBit( __in PDEVICE_OBJECT PhysicalDeviceObject, __in HANDLE File, __in PLARGE_INTEGER Offset, __in ULONG Length, __in PDISK_FLT_DEVICE_EXT DevExt );
VOID WriteWorkThread( __in PVOID Context );
NTSTATUS RestoreDisk( __in PDISK_FLT_DEVICE_EXT DevExt );
BOOLEAN IsRestoreDisk();
#endif
|
0cch
|
branches/SectorMon/SectorMon.h
|
C
|
lgpl
| 4,498
|
#include "SectorMon.h"
BOOLEAN StartFilter = FALSE;
BOOLEAN InitFilter = FALSE;
NTFS_BOOT_SEC BootSec;
GLOBAL_CONTEXT GlobalContext = {0};
USHORT BytesPerSector = 512;
NTSTATUS
RecoverBootStatus()
{
NTSTATUS ns;
HANDLE FileHandle;
OBJECT_ATTRIBUTES oa;
IO_STATUS_BLOCK Iob;
LARGE_INTEGER Offset = {0};
UCHAR Buffer[16];
DECLARE_CONST_UNICODE_STRING(FileName, L"\\??\\C:\\Windows\\bootstat.dat");
InitializeObjectAttributes(&oa, (PUNICODE_STRING)&FileName, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
ns = ZwCreateFile(&FileHandle,
FILE_READ_DATA | FILE_WRITE_DATA | SYNCHRONIZE,
&oa,
&Iob,
NULL,
0,
FILE_SHARE_READ,
FILE_OPEN,
FILE_SYNCHRONOUS_IO_NONALERT,
NULL,
0);
if (!NT_SUCCESS(ns)) {
return ns;
}
ns = ZwReadFile(FileHandle,
NULL,
NULL,
NULL,
&Iob,
Buffer,
16,
&Offset,
NULL);
if (!NT_SUCCESS(ns)) {
ZwClose(FileHandle);
return ns;
}
if (Buffer[10] == 0) {
Buffer[10] = 1;
}
ns = ZwWriteFile(FileHandle,
NULL,
NULL,
NULL,
&Iob,
Buffer,
16,
&Offset,
NULL);
ZwClose(FileHandle);
return ns;
}
BOOLEAN
IsRestoreDisk()
{
NTSTATUS ns;
UNICODE_STRING SecMonName;
UNICODE_STRING RestoreDiskName;
OBJECT_ATTRIBUTES oa;
HANDLE SecMonHandle;
UCHAR ValueBuffer[128];
ULONG RetLength;
PKEY_VALUE_PARTIAL_INFORMATION Value = (PKEY_VALUE_PARTIAL_INFORMATION)ValueBuffer;
RtlInitUnicodeString(&SecMonName, L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\SecMon");
InitializeObjectAttributes(&oa,
&SecMonName,
OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
NULL,
NULL);
ns = ZwOpenKey(&SecMonHandle,
KEY_READ,
&oa);
if (!NT_SUCCESS(ns)) {
return FALSE;
}
RtlInitUnicodeString(&RestoreDiskName, L"Current");
ns = ZwQueryValueKey(SecMonHandle,
&RestoreDiskName,
KeyValuePartialInformation,
ValueBuffer,
sizeof(ValueBuffer),
&RetLength);
ZwClose(SecMonHandle);
if (!NT_SUCCESS(ns)) {
return FALSE;
}
if (*((ULONG *)Value->Data) == 0) {
return FALSE;
}
return TRUE;
}
NTSTATUS
RestoreDisk(
__in PDISK_FLT_DEVICE_EXT DevExt
)
{
ULONGLONG BitCount;
PVOID BitBuf = GlobalContext.MapBuffer;
ULONG BitSize = GlobalContext.MapSize;
LARGE_INTEGER Offset;
ULONGLONG i;
LONG Ret;
PVOID SectorBuf;
NTSTATUS ns = STATUS_SUCCESS;
IO_STATUS_BLOCK Iob;
HANDLE FileHandle = GlobalContext.SparseFileHandle;
PDEVICE_OBJECT PhyDevObj = DevExt->PhysicalDeviceObject;
FILE_DISPOSITION_INFORMATION FileDisInfo;
LARGE_INTEGER Mm3Second = {(ULONG)(-3 * 1000 * 1000 * 10), -1};
BitCount = BitSize << 3;
SectorBuf = ExAllocatePoolWithTag(PagedPool, BytesPerSector, 'rsdk');
for (i = 0; i < BitCount; i++) {
if (i % 0x1000 == 0) {
KdPrint(("Per : %I64d / %I64d\n", i, BitCount));
}
Ret = GetBit(BitBuf, BitSize, i);
ASSERT(Ret != -1);
if (Ret == -1) {
ns = STATUS_UNSUCCESSFUL;
break;
}
else if (Ret == 1) {
Offset.QuadPart = i * BytesPerSector;
ns = ZwReadFile(FileHandle,
NULL,
NULL,
NULL,
&Iob,
SectorBuf,
BytesPerSector,
&Offset,
NULL);
ASSERT(NT_SUCCESS(ns));
if (!NT_SUCCESS(ns)) {
break;
}
ns = DirectReadWrite(PhyDevObj,
DIRECT_WRITE,
SectorBuf,
&Offset,
BytesPerSector);
ASSERT(NT_SUCCESS(ns));
if (!NT_SUCCESS(ns)) {
break;
}
}
}
ExFreePoolWithTag(SectorBuf, 'rsdk');
if (!NT_SUCCESS(ns)) {
return ns;
}
Offset.QuadPart = 0;
RtlZeroMemory(BitBuf, BitSize);
ns = ZwWriteFile(GlobalContext.FileHandle,
NULL,
NULL,
NULL,
&Iob,
BitBuf,
BitSize,
&Offset,
NULL);
if (!NT_SUCCESS(ns)) {
return ns;
}
FileDisInfo.DeleteFile = TRUE;
ns = ZwSetInformationFile(FileHandle,
&Iob,
&FileDisInfo,
sizeof(FILE_DISPOSITION_INFORMATION),
FileDispositionInformation);
if (!NT_SUCCESS(ns)) {
return ns;
}
ZwClose(FileHandle);
ns = RecoverBootStatus();
KeDelayExecutionThread(KernelMode, FALSE, &Mm3Second);
KeBugCheck(POWER_FAILURE_SIMULATE);
}
VOID
WriteWorkThread(
__in PVOID Context
)
{
PWRITE_ELEMENT ReqEntry = NULL;
PDISK_FLT_DEVICE_EXT DevExt = (PDISK_FLT_DEVICE_EXT)Context;
IO_STATUS_BLOCK Iob;
KeSetPriorityThread(KeGetCurrentThread(), LOW_REALTIME_PRIORITY);
for(;;) {
KeWaitForSingleObject(
&DevExt->ReqEvent,
Executive,
KernelMode,
FALSE,
NULL
);
if (DevExt->ThreadFlag) {
PsTerminateSystemThread(STATUS_SUCCESS);
return;
}
while ((ReqEntry = (PWRITE_ELEMENT)ExInterlockedRemoveHeadList(&DevExt->ReqList,
&DevExt->ReqLock)) != NULL) {
ZwWriteFile(ReqEntry->File,
NULL,
NULL,
NULL,
&Iob,
ReqEntry->Buffer,
ReqEntry->Length,
&ReqEntry->Offset,
NULL);
if (ReqEntry->NeedFree) {
ExFreeToPagedLookasideList(&DevExt->SectorBufHeader, ReqEntry->Buffer);
}
ExFreeToPagedLookasideList(&DevExt->WriteElemHeader, ReqEntry);
}
}
}
NTSTATUS
SkipAndCallDriver(
__in PDEVICE_OBJECT DeviceObject,
__in PIRP Irp
)
{
IoSkipCurrentIrpStackLocation(Irp);
return IoCallDriver(DeviceObject, Irp);
}
NTSTATUS
SyncIrpCompletionRoutine(
__in PDEVICE_OBJECT DeviceObject,
__in PIRP Irp,
__in PVOID Context
)
{
PKEVENT Event = (PKEVENT) Context;
UNREFERENCED_PARAMETER(DeviceObject);
if (Irp->PendingReturned) {
KeSetEvent(Event, IO_NO_INCREMENT, FALSE);
}
return STATUS_MORE_PROCESSING_REQUIRED;
}
NTSTATUS
SendSyncIrp(
__in PDEVICE_OBJECT DeviceObject,
__in PIRP Irp
)
{
KEVENT Event;
NTSTATUS ns;
KeInitializeEvent(&Event, NotificationEvent, FALSE);
IoCopyCurrentIrpStackLocationToNext(Irp);
IoSetCompletionRoutine(
Irp,
SyncIrpCompletionRoutine,
&Event,
TRUE,
TRUE,
TRUE);
ns = IoCallDriver(DeviceObject, Irp);
if (ns == STATUS_PENDING) {
KeWaitForSingleObject(
&Event,
Executive,
KernelMode,
FALSE,
NULL);
ns = Irp->IoStatus.Status;
}
return ns;
}
NTSTATUS
DispatchPassThrough(
__in PDEVICE_OBJECT DeviceObject,
__in PIRP Irp
)
{
PDISK_FLT_DEVICE_EXT DevExt = DeviceObject->DeviceExtension;
return SkipAndCallDriver(DevExt->LowerDeviceObject, Irp);
}
NTSTATUS
DispatchPower(
__in PDEVICE_OBJECT DeviceObject,
__in PIRP Irp
)
{
PDISK_FLT_DEVICE_EXT DevExt = DeviceObject->DeviceExtension;
#if (NTDDI_VERSION < NTDDI_VISTA)
PoStartNextPowerIrp(Irp);
IoSkipCurrentIrpStackLocation(Irp);
return PoCallDriver(DevExt->LowerDeviceObject, Irp);
#else
return SkipAndCallDriver(DevExt->LowerDeviceObject, Irp);
#endif
}
NTSTATUS
DispatchPnp(
__in PDEVICE_OBJECT DeviceObject,
__in PIRP Irp
)
{
PDISK_FLT_DEVICE_EXT DevExt = DeviceObject->DeviceExtension;
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
NTSTATUS ns;
switch (IrpSp->MinorFunction) {
case IRP_MN_REMOVE_DEVICE:
{
StartFilter = FALSE;
if (DevExt->LowerDeviceObject != NULL) {
IoDetachDevice(DevExt->LowerDeviceObject);
DevExt->LowerDeviceObject = NULL;
}
if (DevExt->ThreadObject != NULL && DevExt->ThreadFlag != TRUE) {
DevExt->ThreadFlag = TRUE;
KeSetEvent(&DevExt->ReqEvent,
(KPRIORITY)0,
FALSE);
KeWaitForSingleObject(
DevExt->ThreadObject,
Executive,
KernelMode,
FALSE,
NULL
);
ObDereferenceObject(DevExt->ThreadObject);
DevExt->ThreadObject = NULL;
}
ExDeletePagedLookasideList(&DevExt->SectorBufHeader);
ExDeletePagedLookasideList(&DevExt->WriteElemHeader);
if (DevExt->FilterDeviceObject != NULL) {
IoDeleteDevice(DevExt->FilterDeviceObject);
}
if (GlobalContext.FileHandle != NULL) {
CloseMapping(GlobalContext.FileHandle,
GlobalContext.MapBuffer);
GlobalContext.FileHandle = NULL;
}
if (GlobalContext.SparseFileHandle != NULL) {
ZwClose(GlobalContext.SparseFileHandle);
GlobalContext.SparseFileHandle = NULL;
}
}
break;
case IRP_MN_DEVICE_USAGE_NOTIFICATION:
{
if (IrpSp->Parameters.UsageNotification.Type != DeviceUsageTypePaging) {
ns = SkipAndCallDriver(DevExt->LowerDeviceObject, Irp);
return ns;
}
ns = SendSyncIrp(DevExt->LowerDeviceObject, Irp);
if (NT_SUCCESS(ns)) {
if (DevExt->LowerDeviceObject->Flags & DO_POWER_PAGABLE) {
DeviceObject->Flags |= DO_POWER_PAGABLE;
}
else {
DeviceObject->Flags &= ~DO_POWER_PAGABLE;
}
}
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return ns;
}
break;
default:
break;
}
return SkipAndCallDriver(DevExt->LowerDeviceObject, Irp);
}
NTSTATUS
DispatchReadWrite(
__in PDEVICE_OBJECT DeviceObject,
__in PIRP Irp
)
{
PDISK_FLT_DEVICE_EXT DevExt = DeviceObject->DeviceExtension;
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
NTSTATUS ns;
if (StartFilter && InitFilter) {
if (IrpSp->MajorFunction == IRP_MJ_READ) {
// KdPrint(("Read Offset:%016I64X Length:%08X\n",
// IrpSp->Parameters.Read.ByteOffset.QuadPart,
// IrpSp->Parameters.Read.Length));
}
else {
// KdPrint(("Write Offset:%016I64X Length:%08X\n",
// IrpSp->Parameters.Write.ByteOffset.QuadPart,
// IrpSp->Parameters.Write.Length));
ns = BackupSectorAndSetBit(DevExt->PhysicalDeviceObject,
GlobalContext.SparseFileHandle,
&IrpSp->Parameters.Write.ByteOffset,
IrpSp->Parameters.Write.Length,
DevExt);
if (!NT_SUCCESS(ns)) {
KdPrint(("[FAILED] Write Offset:%016I64X Length:%08X\n",
IrpSp->Parameters.Write.ByteOffset.QuadPart,
IrpSp->Parameters.Write.Length));
}
}
}
return SkipAndCallDriver(DevExt->LowerDeviceObject, Irp);
}
NTSTATUS
DispatchDeviceControl(
__in PDEVICE_OBJECT DeviceObject,
__in PIRP Irp
)
{
PDISK_FLT_DEVICE_EXT DevExt = DeviceObject->DeviceExtension;
NTSTATUS ns;
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
KEVENT Event;
PIRP SynIrp;
UCHAR DBR[512];
ULONG DBRLength = 512;
IO_STATUS_BLOCK Iob;
LARGE_INTEGER ReadOffset = {0};
switch (IrpSp->Parameters.DeviceIoControl.IoControlCode) {
case IOCTL_VOLUME_ONLINE:
{
KeInitializeEvent(&Event, NotificationEvent, FALSE);
IoCopyCurrentIrpStackLocationToNext(Irp);
IoSetCompletionRoutine(Irp,
SyncIrpCompletionRoutine,
&Event,
TRUE,
TRUE,
TRUE);
ns = IoCallDriver(DevExt->LowerDeviceObject, Irp);
if (ns == STATUS_PENDING) {
KeWaitForSingleObject(&Event,
Executive,
KernelMode,
FALSE,
NULL);
}
KeClearEvent(&Event);
SynIrp = IoBuildAsynchronousFsdRequest(IRP_MJ_READ,
DevExt->PhysicalDeviceObject,
DBR,
DBRLength,
&ReadOffset,
&Iob);
if (SynIrp != NULL) {
IoSetCompletionRoutine(SynIrp,
SyncIrpCompletionRoutine,
&Event,
TRUE,
TRUE,
TRUE);
ns = IoCallDriver(DevExt->PhysicalDeviceObject, SynIrp);
if(ns == STATUS_PENDING) {
KeWaitForSingleObject(&Event,
Executive,
KernelMode,
FALSE,
NULL);
}
ns = SynIrp->IoStatus.Status;
IoFreeIrp(SynIrp);
if (NT_SUCCESS(ns)) {
RtlCopyMemory(&BootSec, DBR, sizeof(NTFS_BOOT_SEC));
BytesPerSector = BootSec.Bpb.BytesPerSector;
ExInitializePagedLookasideList(&DevExt->SectorBufHeader,
NULL,
NULL,
0,
BytesPerSector,
'back',
0);
StartFilter = TRUE;
}
}
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return ns;
}
break;
default:
break;
}
return SkipAndCallDriver(DevExt->LowerDeviceObject, Irp);
}
NTSTATUS
__fastcall
BackupSectorAndSetBit(
__in PDEVICE_OBJECT PhysicalDeviceObject,
__in HANDLE File,
__in PLARGE_INTEGER Offset,
__in ULONG Length,
__in PDISK_FLT_DEVICE_EXT DevExt
)
{
ULONGLONG BitOffset = BYTEOFF_TO_BITOFF(Offset->QuadPart);
ULONG BitLength = BYTELEN_TO_BITLEN(Length);
ULONG i;
ULONG BitStatus;
BOOLEAN BitRet;
PUCHAR BitBuf = (PUCHAR)GlobalContext.MapBuffer;
ULONG BitSize = GlobalContext.MapSize;
LARGE_INTEGER BackupOffset;
PUCHAR BackupBuf;
NTSTATUS ns;
PWRITE_ELEMENT WriteElem;
ASSERT((Offset->QuadPart % BytesPerSector) == 0);
ASSERT((Length % BytesPerSector) == 0);
for (i = 0; i < BitLength; i++) {
BitStatus = GetBit(BitBuf, BitSize, BitOffset + i);
if (BitStatus == -1) {
return STATUS_UNSUCCESSFUL;
}
else if (BitStatus == 0) {
BackupBuf = ExAllocateFromPagedLookasideList(&DevExt->SectorBufHeader);
BackupOffset.QuadPart = (i + BitOffset) * BytesPerSector;
ns = DirectReadWrite(PhysicalDeviceObject,
DIRECT_READ,
BackupBuf,
&BackupOffset,
BytesPerSector);
if (!NT_SUCCESS(ns)) {
ExFreeToPagedLookasideList(&DevExt->SectorBufHeader, BackupBuf);
return ns;
}
WriteElem = (PWRITE_ELEMENT)ExAllocateFromPagedLookasideList(&DevExt->WriteElemHeader);
if (WriteElem == NULL) {
ExFreeToPagedLookasideList(&DevExt->SectorBufHeader, BackupBuf);
return STATUS_INSUFFICIENT_RESOURCES;
}
WriteElem->File = File;
WriteElem->Buffer = BackupBuf;
WriteElem->Length = BytesPerSector;
WriteElem->Offset.QuadPart = BackupOffset.QuadPart;
WriteElem->NeedFree = TRUE;
WriteElem->Tag = 'back';
ExInterlockedInsertTailList(&DevExt->ReqList,
&WriteElem->ListEntry,
&DevExt->ReqLock);
KeSetEvent(&DevExt->ReqEvent,
(KPRIORITY)0,
FALSE);
BitRet = SetBit(BitBuf, BitSize, BitOffset + i);
if (!BitRet) {
return STATUS_UNSUCCESSFUL;
}
}
}
FlushBuffer(DevExt,
GlobalContext.FileHandle,
BitBuf,
BITOFF_TO_MAPOFF(BitOffset),
BITLEN_TO_MAPLEN(BitOffset, BitLength));
return STATUS_SUCCESS;
}
NTSTATUS
FlushBuffer(
__in PDISK_FLT_DEVICE_EXT DevExt,
__in HANDLE File,
__in PVOID Buffer,
__in ULONG Offset,
__in ULONG Size
)
{
PUCHAR FlushBuf = (PUCHAR)Buffer;
PWRITE_ELEMENT WriteElem = (PWRITE_ELEMENT)ExAllocateFromPagedLookasideList(&DevExt->WriteElemHeader);
if (WriteElem == NULL) {
return STATUS_INSUFFICIENT_RESOURCES;
}
WriteElem->File = File;
WriteElem->Buffer = FlushBuf + Offset;
WriteElem->Length = Size;
WriteElem->Offset.QuadPart = (LONGLONG)Offset;
WriteElem->NeedFree = FALSE;
ExInterlockedInsertTailList(&DevExt->ReqList,
&WriteElem->ListEntry,
&DevExt->ReqLock);
KeSetEvent(&DevExt->ReqEvent,
(KPRIORITY)0,
FALSE);
return STATUS_SUCCESS;
}
NTSTATUS
DirectReadWrite(
__in PDEVICE_OBJECT DeviceObject,
__in ULONG ReadWrite,
__out PVOID Buffer,
__in PLARGE_INTEGER Offset,
__in ULONG Length
)
{
NTSTATUS ns;
ULONG MjFunc;
KEVENT Event;
PIRP Irp;
IO_STATUS_BLOCK Iob;
PMDL NextMdl;
if (ReadWrite == DIRECT_READ) {
MjFunc = IRP_MJ_READ;
}
else if (ReadWrite == DIRECT_WRITE) {
MjFunc = IRP_MJ_WRITE;
}
else {
return STATUS_INVALID_PARAMETER;
}
KeInitializeEvent(&Event, NotificationEvent, FALSE);
Irp = IoBuildAsynchronousFsdRequest(MjFunc,
DeviceObject,
Buffer,
Length,
Offset,
&Iob);
if (Irp == NULL) {
return STATUS_INSUFFICIENT_RESOURCES;
}
IoSetCompletionRoutine(Irp,
SyncIrpCompletionRoutine,
&Event,
TRUE,
TRUE,
TRUE);
ns = IoCallDriver(DeviceObject, Irp);
if(ns == STATUS_PENDING) {
KeWaitForSingleObject(&Event,
Executive,
KernelMode,
FALSE,
NULL);
}
ns = Irp->IoStatus.Status;
while (Irp->MdlAddress != NULL) {
NextMdl = Irp->MdlAddress->Next;
MmUnlockPages(Irp->MdlAddress);
IoFreeMdl(Irp->MdlAddress);
Irp->MdlAddress = NextMdl;
}
IoFreeIrp(Irp);
return ns;
}
LONGLONG GetFileSize(
__in HANDLE Handle
)
{
IO_STATUS_BLOCK Iob;
FILE_STANDARD_INFORMATION FileStdInfo;
NTSTATUS ns;
ns = ZwQueryInformationFile(Handle,
&Iob,
&FileStdInfo,
sizeof(FILE_STANDARD_INFORMATION),
FileStandardInformation);
if (!NT_SUCCESS(ns)) {
return 0;
}
return FileStdInfo.EndOfFile.QuadPart;
}
BOOLEAN
__fastcall
SetBit(
__in PUCHAR BitBuf,
__in ULONG BitSize,
__in ULONGLONG Bit
)
{
ULONG ByteOffset = 0;
ULONG BitOffset = 0;
ByteOffset = (ULONG)(Bit / 8);
if (ByteOffset >= BitSize) {
return FALSE;
}
BitOffset = (ULONG)(Bit % 8);
BitBuf[ByteOffset] |= (UCHAR)(1 << BitOffset);
return TRUE;
}
BOOLEAN
__fastcall
ClearBit(
__in PUCHAR BitBuf,
__in ULONG BitSize,
__in ULONGLONG Bit
)
{
ULONG ByteOffset = 0;
ULONG BitOffset = 0;
ByteOffset = (ULONG)(Bit / 8);
if (ByteOffset >= BitSize) {
return FALSE;
}
BitOffset = (ULONG)(Bit % 8);
BitBuf[ByteOffset] &= (UCHAR)(~(1 << BitOffset));
return TRUE;
}
ULONG
__fastcall
GetBit(
__in PUCHAR BitBuf,
__in ULONG BitSize,
__in ULONGLONG Bit
)
{
ULONG ByteOffset = 0;
ULONG BitOffset = 0;
ByteOffset = (ULONG)(Bit / 8);
if (ByteOffset >= BitSize) {
return (ULONG)-1;
}
BitOffset = (ULONG)(Bit % 8);
return (BitBuf[ByteOffset] & (UCHAR)(1 << BitOffset)) != 0;
}
NTSTATUS
OpenMapping(
__in PWCHAR Name,
__out PHANDLE File,
__out PVOID *Buffer,
__out ULONG *BufferSize
)
{
NTSTATUS ns;
HANDLE FileHandle;
UNICODE_STRING FileName;
OBJECT_ATTRIBUTES oa;
IO_STATUS_BLOCK Iob;
LARGE_INTEGER MaxSize;
PVOID MapBuffer;
LARGE_INTEGER Offset = {0};
RtlInitUnicodeString(&FileName, Name);
InitializeObjectAttributes(&oa, &FileName, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
ns = ZwCreateFile(&FileHandle,
FILE_READ_DATA | FILE_WRITE_DATA | SYNCHRONIZE,
&oa,
&Iob,
NULL,
0,
FILE_SHARE_READ,
FILE_OPEN,
FILE_SYNCHRONOUS_IO_NONALERT | FILE_WRITE_THROUGH,
NULL,
0);
if (!NT_SUCCESS(ns)) {
return ns;
}
MaxSize.QuadPart = GetFileSize(FileHandle);
if (MaxSize.QuadPart == 0) {
ZwClose(FileHandle);
return STATUS_UNSUCCESSFUL;
}
MapBuffer = ExAllocatePoolWithTag(PagedPool, MaxSize.LowPart, 'bmp ');
if (MapBuffer == NULL) {
ZwClose(FileHandle);
return STATUS_INSUFFICIENT_RESOURCES;
}
ns = ZwReadFile(FileHandle, NULL, NULL, NULL, &Iob, MapBuffer, MaxSize.LowPart, &Offset, NULL);
if (!NT_SUCCESS(ns)) {
ExFreePoolWithTag(MapBuffer, 'bmp ');
ZwClose(FileHandle);
return ns;
}
*File = FileHandle;
*Buffer = MapBuffer;
*BufferSize = MaxSize.LowPart;
return ns;
}
VOID
CloseMapping(
__in HANDLE File,
__in PVOID Buffer
)
{
ExFreePoolWithTag(Buffer, 'bmp ');
ZwClose(File);
}
NTSTATUS
CreateSparseFile(
__out PHANDLE Handle,
__in PWCHAR FileName,
__in ULONGLONG FileSize,
__in BOOLEAN Restore
)
{
NTSTATUS ns;
HANDLE FileHandle;
UNICODE_STRING SparseFileName;
IO_STATUS_BLOCK Iob;
OBJECT_ATTRIBUTES oa;
FILE_END_OF_FILE_INFORMATION FileEndInfo = {0};
ULONG ExtFlag = 0;
if (!Restore) {
ExtFlag = FILE_RANDOM_ACCESS | FILE_NO_INTERMEDIATE_BUFFERING | FILE_WRITE_THROUGH;
}
RtlInitUnicodeString(&SparseFileName, FileName);
InitializeObjectAttributes(&oa,
&SparseFileName,
OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
NULL,
NULL);
ns = ZwCreateFile(
&FileHandle,
FILE_READ_DATA | FILE_WRITE_DATA | SYNCHRONIZE | DELETE,
&oa,
&Iob,
NULL,
FILE_ATTRIBUTE_NORMAL,
0,
FILE_OPEN_IF,
FILE_SYNCHRONOUS_IO_NONALERT | ExtFlag,
NULL,
0);
if(!NT_SUCCESS(ns)) {
return ns;
}
if (Iob.Information == FILE_CREATED) {
ns = ZwFsControlFile(FileHandle,
NULL,
NULL,
NULL,
&Iob,
FSCTL_SET_SPARSE,
NULL,
0,
NULL,
0);
if(!NT_SUCCESS(ns)) {
ZwClose(FileHandle);
return ns;
}
FileEndInfo.EndOfFile.QuadPart = FileSize + 10*1024*1024;
ns = ZwSetInformationFile(FileHandle,
&Iob,
&FileEndInfo,
sizeof(FILE_END_OF_FILE_INFORMATION),
FileEndOfFileInformation);
if (!NT_SUCCESS(ns)) {
ZwClose(FileHandle);
return ns;
}
}
*Handle = FileHandle;
return ns;
}
NTSTATUS
AddDevice(
__in PDRIVER_OBJECT DriverObject,
__in PDEVICE_OBJECT PhysicalDeviceObject
)
{
NTSTATUS ns;
PDISK_FLT_DEVICE_EXT DevExt;
PDEVICE_OBJECT LowerDevObj;
PDEVICE_OBJECT FltDevObj;
ULONG RetLength;
HANDLE ThreadHandle;
UCHAR NameBuffer[1024 + sizeof(OBJECT_NAME_INFORMATION)];
POBJECT_NAME_INFORMATION DeviceNameInfo = (POBJECT_NAME_INFORMATION)NameBuffer;
DECLARE_CONST_UNICODE_STRING(Vol1, L"\\Device\\HarddiskVolume1");
ns = ObQueryNameString(PhysicalDeviceObject, DeviceNameInfo, 1024, &RetLength);
if (!NT_SUCCESS(ns)) {
return ns;
}
if (RtlCompareUnicodeString(&Vol1, &DeviceNameInfo->Name, TRUE) != 0) {
return STATUS_SUCCESS;
}
KdPrint(("Physical Device Dos Name : %wZ\n", &DeviceNameInfo->Name));
ns = IoCreateDevice(DriverObject,
sizeof(DISK_FLT_DEVICE_EXT),
NULL,
FILE_DEVICE_DISK,
FILE_DEVICE_SECURE_OPEN,
FALSE,
&FltDevObj);
if (!NT_SUCCESS(ns)) {
return ns;
}
DevExt = FltDevObj->DeviceExtension;
RtlZeroMemory(DevExt,sizeof(DISK_FLT_DEVICE_EXT));
LowerDevObj = IoAttachDeviceToDeviceStack(FltDevObj,
PhysicalDeviceObject);
if (LowerDevObj == NULL) {
IoDeleteDevice(FltDevObj);
ns = STATUS_NO_SUCH_DEVICE;
return ns;
}
FltDevObj->Flags |= LowerDevObj->Flags & (DO_DIRECT_IO | DO_BUFFERED_IO | DO_POWER_PAGABLE);
FltDevObj->Flags &= ~DO_DEVICE_INITIALIZING;
DevExt->DeviceType = DEVICE_TYPE_FILTER;
DevExt->FilterDeviceObject = FltDevObj;
DevExt->PhysicalDeviceObject = PhysicalDeviceObject;
DevExt->LowerDeviceObject = LowerDevObj;
InitializeListHead(&DevExt->ReqList);
KeInitializeSpinLock(&DevExt->ReqLock);
KeInitializeEvent(&DevExt->ReqEvent,
SynchronizationEvent,
FALSE);
DevExt->ThreadFlag = FALSE;
ns = PsCreateSystemThread(&ThreadHandle,
(ACCESS_MASK)0L,
NULL,
NULL,
NULL,
WriteWorkThread,
DevExt);
if (!NT_SUCCESS(ns)) {
IoDeleteDevice(FltDevObj);
return ns;
}
ns = ObReferenceObjectByHandle(ThreadHandle,
THREAD_ALL_ACCESS,
NULL,
KernelMode,
&DevExt->ThreadObject,
NULL);
ZwClose(ThreadHandle);
if (!NT_SUCCESS(ns)) {
DevExt->ThreadFlag = TRUE;
KeSetEvent(&DevExt->ReqEvent,
(KPRIORITY)0,
FALSE);
IoDeleteDevice(FltDevObj);
return ns;
}
ExInitializePagedLookasideList(&DevExt->WriteElemHeader,
NULL,
NULL,
0,
sizeof(WRITE_ELEMENT),
'welm',
0);
return ns;
}
VOID
Unload(
__in PDRIVER_OBJECT DriverObject
)
{
PDEVICE_OBJECT NextDevObj;
PDEVICE_OBJECT CurDevObj;
PDISK_FLT_DEVICE_EXT DevExt;
NextDevObj = DriverObject->DeviceObject;
while (NextDevObj != NULL) {
CurDevObj = NextDevObj;
DevExt = (PDISK_FLT_DEVICE_EXT)CurDevObj->DeviceExtension;
NextDevObj = CurDevObj->NextDevice;
if (DevExt->DeviceType == DEVICE_TYPE_FILTER) {
IoDetachDevice(DevExt->LowerDeviceObject);
if (DevExt->ThreadObject != NULL && DevExt->ThreadFlag != TRUE) {
DevExt->ThreadFlag = TRUE;
KeSetEvent(&DevExt->ReqEvent,
(KPRIORITY)0,
FALSE);
KeWaitForSingleObject(
DevExt->ThreadObject,
Executive,
KernelMode,
FALSE,
NULL
);
ObDereferenceObject(DevExt->ThreadObject);
DevExt->ThreadObject = NULL;
}
ExDeletePagedLookasideList(&DevExt->SectorBufHeader);
ExDeletePagedLookasideList(&DevExt->WriteElemHeader);
DevExt->LowerDeviceObject = NULL;
}
IoDeleteDevice(CurDevObj);
}
if (GlobalContext.FileHandle != NULL) {
CloseMapping(GlobalContext.FileHandle,
GlobalContext.MapBuffer);
GlobalContext.FileHandle = NULL;
}
if (GlobalContext.SparseFileHandle != NULL) {
ZwClose(GlobalContext.SparseFileHandle);
GlobalContext.SparseFileHandle = NULL;
}
return;
}
VOID
ReinitializationRoutine(
__in PDRIVER_OBJECT DriverObject,
__in PVOID Context,
__in ULONG Count
)
{
NTSTATUS ns;
PDEVICE_OBJECT FilterDevice;
PDISK_FLT_DEVICE_EXT DevExt;
BOOLEAN PrepareRestore = IsRestoreDisk();
UNREFERENCED_PARAMETER(DriverObject);
UNREFERENCED_PARAMETER(Context);
UNREFERENCED_PARAMETER(Count);
ns = OpenMapping(L"\\??\\D:\\Bitmap.dat",
&GlobalContext.FileHandle,
&GlobalContext.MapBuffer,
&GlobalContext.MapSize);
if (!NT_SUCCESS(ns)) {
return;
}
ns = CreateSparseFile(&GlobalContext.SparseFileHandle,
L"\\??\\D:\\SpareFile.dat",
BootSec.ExBpb.TotalSectors * BootSec.Bpb.BytesPerSector, PrepareRestore);
if (!NT_SUCCESS(ns)) {
return;
}
if (PrepareRestore) {
FilterDevice = DriverObject->DeviceObject;
while (FilterDevice != NULL) {
DevExt = FilterDevice->DeviceExtension;
if (DevExt != NULL && DevExt->DeviceType == DEVICE_TYPE_FILTER) {
RestoreDisk(DevExt);
KdBreakPoint();
}
FilterDevice = FilterDevice->NextDevice;
}
}
InitFilter = TRUE;
return;
}
NTSTATUS
DriverEntry(
__in PDRIVER_OBJECT DriverObject,
__in PUNICODE_STRING RegistryPath
)
{
ULONG i;
UNREFERENCED_PARAMETER(RegistryPath);
KdBreakPoint();
for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++) {
DriverObject->MajorFunction[i] = DispatchPassThrough;
}
DriverObject->MajorFunction[IRP_MJ_POWER] = DispatchPower;
DriverObject->MajorFunction[IRP_MJ_PNP] = DispatchPnp;
DriverObject->MajorFunction[IRP_MJ_READ] = DispatchReadWrite;
DriverObject->MajorFunction[IRP_MJ_WRITE] = DispatchReadWrite;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DispatchDeviceControl;
DriverObject->DriverExtension->AddDevice = AddDevice;
DriverObject->DriverUnload = Unload;
IoRegisterBootDriverReinitialization(DriverObject,
ReinitializationRoutine,
NULL);
return STATUS_SUCCESS;
}
|
0cch
|
branches/SectorMon/SectorMon.c
|
C
|
lgpl
| 26,789
|
public class TestSVNCode {
//nhom google code nhom 8
public static void main(String[] args)
{
System.out.println("hello world");
System.out.println("hello world");
System.out.println("nhom 8");
}
}
|
00da-2014-group08
|
TestSVNCode/src/TestSVNCode.java
|
Java
|
epl
| 221
|
#-------------------------------------------------
#
# Project created by QtCreator 2010-07-08T08:02:01
#
#-------------------------------------------------
QT += core gui network
TARGET = 1000Bornes
TEMPLATE = app
#CONFIG += debug
CONFIG += console
DEPENDPATH += . src src/engine src/gui src/network
INCLUDEPATH += . src src/engine src/gui src/network
SOURCES += main.cpp\
src/gui/MainWindow.cpp \
src/engine/Card.cpp \
src/engine/Tableau.cpp \
src/engine/Hand.cpp \
src/engine/DrawPile.cpp \
src/engine/DiscardPile.cpp \
src/engine/Player.cpp \
src/engine/Team.cpp \
src/engine/RaceInfo.cpp \
src/gui/Skin.cpp \
src/engine/CardInfo.cpp \
src/Properties.cpp
HEADERS += includes.h\
src/gui/MainWindow.h \
src/engine/Card.h \
src/engine/Tableau.h \
src/engine/Hand.h \
src/engine/DrawPile.h \
src/engine/DiscardPile.h \
src/engine/Player.h \
src/engine/Team.h \
src/engine/RaceInfo.h \
src/gui/Skin.h \
src/engine/CardInfo.h \
src/Properties.h
FORMS += MainWindow.ui
RESOURCES += resources.qrc
OTHER_FILES += resource.rc
win32:RC_FILE += resource.rc
|
1000-bornes
|
trunk/1000Bornes.pro
|
QMake
|
gpl3
| 1,215
|
#include "Skin.h"
Skin::Skin(QString name, QString extension, QString path) {
this->name = name;
this->extension = extension;
this->path = path;
}
/**
* Create a skin instance from a path (must have at least a valid info.ini file)
*/
Skin* Skin::fromPath(QString path) {
// Checking the ini file for Name and Extension
QSettings settings(QDir::cleanPath(path + "/" + Properties::SKINSNFO), QSettings::IniFormat);
QString name = settings.value("name",tr("Default skin")).toString();
QString extension = settings.value("extension",Properties::DEFAULT_EXTENSION).toString();
return new Skin(name, extension, path);
}
/**
* Create the default skin instance.
*/
Skin* Skin::fromDefault() {
return new Skin(tr("Default skin"), Properties::DEFAULT_EXTENSION, Properties::DEFAULT_CARDPATH);
}
/**
* Gather a list of skins in the SKINSPATH dir.
* The output is a hashmap containing dirpath-skinname pair.
* (the former is used for path to skin content, the later for actual name)
*/
QHash<QString,QString> Skin::skins() {
QHash<QString,QString> skinNames;
/* Looking for Skin directories... */
QDir skinsDir(Properties::SKINSPATH);
skinsDir.setFilter(QDir::Dirs | QDir::NoSymLinks | QDir::NoDotAndDotDot);
skinsDir.setSorting(QDir::Name);
QStringList entryList = skinsDir.entryList();
/* For each directory, looking for the name in the info.ini */
foreach(QString dir, entryList) {
QString dirPath = Properties::SKINSPATH + "/" + dir;
QString nfoPath = dirPath + "/" + Properties::SKINSNFO;
QSettings settings(QDir::cleanPath(nfoPath), QSettings::IniFormat);
// We say skin exists if there is a non-empty name present in the ini
QString name = settings.value("name","").toString();
// If the skin exists, adding it
if (!name.isEmpty()) skinNames[dirPath] = name;
}
return skinNames;
}
QString Skin::imageUrlNormal(QString basename) {
return imageUrl(basename);
}
QString Skin::imageUrlThumb(QString basename) {
return imageUrl(basename, Properties::CARD_APPEND);
}
QString Skin::imageUrlCardBackNormal() {
return imageUrlNormal(Properties::FILENAME_CardBack);
}
QString Skin::imageUrlCardBackThumb() {
return imageUrlThumb(Properties::FILENAME_CardBack);
}
QString Skin::imageUrlCoupFourre() {
return imageUrlNormal(Properties::FILENAME_CoupFourre);
}
/**
* According to a card basename (e.g. hazard_outofgas), will calculate the whole path to the card picture:
* the skin path (or default skin internal path) + basename + extension
*
* The append parameter allow to have the normal or thumbnailed image.
*/
QString Skin::imageUrl(QString basename, QString append) {
QString defaultURL = QDir::cleanPath(Properties::DEFAULT_CARDPATH + "/" + basename + append + "." + Properties::DEFAULT_EXTENSION);
QString skinURL = QDir::cleanPath(path + "/" + basename + append + "." + extension);
// Setting the path to default or skin path (if available)
QFileInfo skinNfo(skinURL);
if (skinNfo.exists() && skinNfo.isReadable())
return skinURL;
return defaultURL;
}
QString Skin::getName() {
return name;
}
|
1000-bornes
|
trunk/src/gui/Skin.cpp
|
C++
|
gpl3
| 3,237
|
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
namespace Ui {
class MainWindow;
}
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();
private:
Ui::MainWindow *ui;
};
#endif // MAINWINDOW_H
|
1000-bornes
|
trunk/src/gui/MainWindow.h
|
C++
|
gpl3
| 317
|
#include "MainWindow.h"
#include "ui_MainWindow.h"
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
}
MainWindow::~MainWindow()
{
delete ui;
}
|
1000-bornes
|
trunk/src/gui/MainWindow.cpp
|
C++
|
gpl3
| 233
|
#ifndef SKIN_H
#define SKIN_H
#include "includes.h"
/**
* Proxy class to handle card skins. Allows to:
* - Skins listing with proper names
* - Skins "loading" (only loads name, properties and path)
* - Proxying each card file path: skin path if it exists, default path else
*/
class Skin : public QObject {
Q_OBJECT
public:
static QHash<QString,QString> skins();
static Skin* fromPath(QString path);
static Skin* fromDefault();
QString imageUrlNormal(QString basename);
QString imageUrlThumb(QString basename);
QString imageUrlCardBackNormal();
QString imageUrlCardBackThumb();
QString imageUrlCoupFourre();
QString getName();
private:
explicit Skin(QString name, QString extension, QString path);
QString name;
QString extension;
QString path;
QString imageUrl(QString basename, QString append = "");
};
#endif // SKIN_H
|
1000-bornes
|
trunk/src/gui/Skin.h
|
C++
|
gpl3
| 893
|
#ifndef PROPERTIES_H
#define PROPERTIES_H
#include <QString>
class Properties {
public:
// Application
static const QString ORGANIZATION;
static const QString APPLICATION;
static const QString SETTINGS;
// Networking
static const quint16 DEFAULT_LISTENPORT;
// Cards informations
static const QString DEFAULT_EXTENSION;
static const QString DEFAULT_CARDPATH;
static const QString CARD_APPEND;
static const QString SKINSPATH;
static const QString SKINSNFO;
// Cards file basenames
static const QString FILENAME_Distance_25;
static const QString FILENAME_Distance_50;
static const QString FILENAME_Distance_75;
static const QString FILENAME_Distance_100;
static const QString FILENAME_Distance_200;
static const QString FILENAME_Hazard_Accident;
static const QString FILENAME_Hazard_OutOfGas;
static const QString FILENAME_Hazard_FlatTire;
static const QString FILENAME_Hazard_SpeedLimit;
static const QString FILENAME_Hazard_Stop;
static const QString FILENAME_Remedy_Repair;
static const QString FILENAME_Remedy_Gasoline;
static const QString FILENAME_Remedy_SpareTire;
static const QString FILENAME_Remedy_EndOfLimit;
static const QString FILENAME_Remedy_Roll;
static const QString FILENAME_Safety_DrivingAce;
static const QString FILENAME_Safety_ExtraTank;
static const QString FILENAME_Safety_PunctureProof;
static const QString FILENAME_Safety_RightOfWay;
static const QString FILENAME_CardBack;
static const QString FILENAME_CoupFourre;
private:
explicit Properties();
};
#endif // PROPERTIES_H
|
1000-bornes
|
trunk/src/Properties.h
|
C++
|
gpl3
| 1,630
|
#ifndef INCLUDES_H
#define INCLUDES_H
// Application properties
#include "Properties.h"
/* Common includes for classes */
#include <QApplication>
#include <QObject>
#include <QDebug>
// GUI
/*#include <QSplashScreen>
#include <QLabel>
#include <QMessageBox>
#include <QCheckBox>
#include <QFileDialog>
#include <QIcon>
#include <QStyle>
#include <QTreeWidget>
#include <QTreeWidgetItem>
#include <QHeaderView>
#include <QComboBox>
#include <QScrollbar>
#include <QProgressBar>
#include <QPalette>
// Drag&Drop
#include <QMimeData>
#include <QDropEvent>
#include <QDragEnterEvent>*/
// String stuff
#include <QString>
#include <QStringList>
#include <QByteArray>
//#include <QRegExp>
//#include <QTextCodec>
// File access stuff
#include <QFile>
#include <QFileInfo>
#include <QDir>
/*#include <QTextStream>
#include <QUrl>*/
// Lists and maps
#include <QList>
#include <QHash>
#include <QMap>
// Settings
#include <QSettings>
#include <QIntValidator>
// Network
#include <QNetworkAccessManager>
#include <QNetworkRequest>
#include <QNetworkReply>
#include <QNetworkProxy>
#include <QNetworkCookie>
#include <QNetworkCookieJar>
#include <QTcpServer>
#include <QTcpSocket>
// Images
#include <QImage>
#include <QPixmap>
// Misc
#include <QFlags>
#endif // INCLUDES_H
|
1000-bornes
|
trunk/src/includes.h
|
C
|
gpl3
| 1,364
|
#ifndef CARDINFO_H
#define CARDINFO_H
#include "includes.h"
class CardInfo : public QObject {
Q_OBJECT
public:
/* Function of the card: Distance, hazard, remedy or safety */
enum FunctionType {
Function_NoFunction, // NoCard
Function_Distance,
Function_Hazard,
Function_Remedy,
Function_Safety
};
typedef FunctionType CardFunction;
/* Nature of the card, for compatibility between a hazard and its remedy/safety */
enum NatureTypeEnum {
Nature_NoNature = 0, // Distance cards / NoCard
Nature_Accident = 1,
Nature_Gas = 2,
Nature_Tire = 4,
Nature_Speed = 8,
Nature_Light = 16
};
// Declares the enum as a QFlags (typedef QFlags<NatureTypeEnum> NatureType;)
Q_DECLARE_FLAGS(NatureType, NatureTypeEnum)
typedef NatureType CardNature;
public:
explicit CardInfo(QString name, QString filename, CardFunction function, CardNature nature, int distance);
QString getName() const;
QString getFilename() const;
CardFunction getFunction() const;
CardNature getNature() const;
int getDistance() const;
private:
QString name;
QString filename;
CardFunction function;
CardNature nature;
int distance;
};
// Declares operator|() for CardNature enum-flag
Q_DECLARE_OPERATORS_FOR_FLAGS(CardInfo::NatureType)
typedef CardInfo::FunctionType CardFunction;
typedef CardInfo::NatureType CardNature;
#endif // CARDINFO_H
|
1000-bornes
|
trunk/src/engine/CardInfo.h
|
C++
|
gpl3
| 1,453
|
#include "Tableau.h"
Tableau::Tableau(Team* owningTeam) {
this->owningTeam = owningTeam;
this->winDistance = 1000; // Let's say default value. Can be set/"extended" during gameplay
}
Tableau::~Tableau() {
this->owningTeam = NULL;
}
/**
* The number of 200km already played.
*/
int Tableau::numberOf200() const {
return distanceArea.count(Card::CardID_Distance_200);
}
/**
* The distance already played.
*/
int Tableau::distance() const {
return (200 * distanceArea.count(Card::CardID_Distance_200))
+ (100 * distanceArea.count(Card::CardID_Distance_100))
+ (75 * distanceArea.count(Card::CardID_Distance_75))
+ (50 * distanceArea.count(Card::CardID_Distance_50))
+ (25 * distanceArea.count(Card::CardID_Distance_25));
}
/**
* Calculates whether or not we can roll on this tableau.
*/
bool Tableau::canRoll() const {
CardID topBattle = battlePile.isEmpty() ? Card::CardID_NoCard : battlePile.last();
// Roll if top is Roll card.
if (topBattle == Card::CardID_Remedy_Roll)
return true;
/* Without a Roll, all other rules need the Right Of Way */
if (!safetyArea.contains(Card::CardID_Safety_RightOfWay))
return false;
// Roll if battle pile empty (+ Right of Way)
if (topBattle == Card::CardID_NoCard)
return true;
// Roll if top is a Remedy (+ Right of Way)
if (Card::getInfo(topBattle)->getFunction() == CardInfo::Function_Remedy)
return true;
// Roll if top is a Hazard and we have the Safety (+ Right of Way)
if ((Card::getInfo(topBattle)->getFunction() == CardInfo::Function_Hazard)
&& safetyArea.contains(Card::cardForProperties(CardInfo::Function_Safety, Card::getInfo(topBattle)->getNature())))
return true;
// If everything else fails.
return false;
}
/**
* Using the canRoll() method, calculates the max value we can roll at a time.
* This might be limited by: the amount of 200 played, a speed limit, or the winDistance
*/
int Tableau::canRollDistance() const {
if (!canRoll()) return 0;
// Let's juste progressively reduce the distance.
int distance = 200;
// Max of 200 km = 2.
if (numberOf200() >= 2) distance = 100;
// If there is a speed limit
if (!speedPile.isEmpty() && speedPile.last() == Card::CardID_Hazard_SpeedLimit)
distance = 50;
// If we're still over winDistance, limiting to it.
int addedDistance = this->distance() + distance;
if (addedDistance > winDistance) {
int excess = addedDistance - winDistance;
distance = qMax(distance - excess, 0);
}
return distance;
}
/**
* One of the core functions of the engine:
* determine whether a player's card can be played on this tableau.
*/
bool Tableau::canPlay(Player* player, CardID card) const {
// No valid card to play.
if (card == Card::CardID_NoCard) return false;
// Gathering information we need
CardInfo* info = Card::getInfo(card); // card info
bool allyPlayer = owningTeam->contains(player); // is this the player's tableau?
//CardID safety = Card::CardID_NoCard; // the safety corresponding to the nature of the card
switch (info->getFunction()) {
/* Distance card */
case CardInfo::Function_Distance:
// Play only on our team's tableau.
if (!allyPlayer)
return false;
/* Play only if the card is within the "canRoll" distance. This include:
- checking if we can roll (Roll card of with safeties),
- checking the 200km cards,
- checking speed limits,
- checking whether the winDistance is exceeded.
*/
qDebug() << "lol" << canRollDistance();
return (info->getDistance() <= canRollDistance());
break;
/* Hazard card */
case CardInfo::Function_Hazard:
// Play only on enemy tableau
if (allyPlayer)
return false;
// Cannot play if the corresponding safety is there
//safety = Card::cardForProperties(CardInfo::Function_Safety, info->getNature());
if (safetyArea.keys().contains( Card::cardForProperties(CardInfo::Function_Safety, info->getNature()) ))
return false;
// Speed limit: empty pile or top=remedy
if (info->getNature() == CardInfo::Nature_Speed) {
return (speedPile.isEmpty() || speedPile.last() == Card::CardID_Remedy_EndOfLimit);
}
// Hazard: only if enemy can roll
else {
return canRoll();
}
break;
/* Remedy cards */
case CardInfo::Function_Remedy:
// Play only on our team's tableau.
if (!allyPlayer)
return false;
// Cannot play if the corresponding safety is there (well, useless at least)
if (safetyArea.keys().contains( Card::cardForProperties(CardInfo::Function_Safety, info->getNature()) ))
return false;
// End of limit: !empty pile and top=limit
if (info->getNature() == CardInfo::Nature_Speed) {
return (!speedPile.isEmpty() && speedPile.last() == Card::CardID_Hazard_SpeedLimit);
}
// Remedy: only if the corresponding hazard is there
else {
// Special case of Roll: can play if there is no card, or a remedy (or Stop, but handled normally after)
if ((card == Card::CardID_Remedy_Roll)
&& (battlePile.isEmpty() || Card::getInfo(battlePile.last())->getFunction() == CardInfo::Function_Remedy))
return true;
return (!battlePile.isEmpty() && (battlePile.last() == Card::cardForProperties(CardInfo::Function_Hazard, info->getNature())));
}
break;
/* Safety card */
case CardInfo::Function_Safety:
// As long as it's our tableau, we can play anytime.
return allyPlayer;
break;
default:
return false;
break;
}
return false;
}
QList<CardID> Tableau::play(CardID card, bool coupFourre) {
QList<CardID> discard;
CardInfo* info = Card::getInfo(card);
if (info == NULL) return discard;
switch (info->getFunction()) {
// Distance cards, added to the list
case CardInfo::Function_Distance:
distanceArea += card;
break;
// Hazards and Remedy, added to the battle or speed list (depends)
case CardInfo::Function_Hazard:
case CardInfo::Function_Remedy:
if (info->getNature() == CardInfo::Nature_Speed)
speedPile += card;
else
battlePile += card;
break;
// Safety cards in the safety area
case CardInfo::Function_Safety:
safetyArea[card] = coupFourre;
if (coupFourre) {
if ((card == Card::CardID_Safety_RightOfWay) && (speedPile.size() > 0) && (speedPile.last() == Card::CardID_Hazard_SpeedLimit))
discard += speedPile.takeLast();
if ((battlePile.size() > 0) && (Card::getInfo(battlePile.last())->getFunction() & CardInfo::Function_Hazard))
discard += battlePile.takeLast();
}
break;
default:
break;
}
return discard;
}
//int Tableau::points();
//QDebug operator<<(QDebug dbg, const Tableau &tab);
QDebug operator<<(QDebug dbg, const Tableau &tab) {
dbg.nospace() <<
"Battle: " << tab.battlePile <<
" / Speed: " << tab.speedPile <<
" / Distance [" + QString::number(tab.numberOf200()) + "/" + QString::number(tab.distance()) + "]: " << tab.distanceArea <<
" / Safeties: " << tab.safetyArea;
return dbg.space();
}
|
1000-bornes
|
trunk/src/engine/Tableau.cpp
|
C++
|
gpl3
| 7,398
|
#ifndef DISCARDPILE_H
#define DISCARDPILE_H
#include "includes.h"
#include "Card.h"
class DiscardPile : public QList<CardID> {
public:
explicit DiscardPile();
};
#endif // DISCARDPILE_H
|
1000-bornes
|
trunk/src/engine/DiscardPile.h
|
C++
|
gpl3
| 205
|
#include "RaceInfo.h"
RaceInfo::RaceInfo() {
this->numberOfCards = 0;
this->extension = false;
this->extensionAllowed = false;
this->normalDistance = 1000;
this->extensionDistance = 1000;
}
RaceInfo::RaceInfo(int numberOfCard, bool extension, bool extensionAllowed, int normalDistance, int extensionDistance) {
this->numberOfCards = numberOfCard;
this->extension = extension;
this->extensionAllowed = extensionAllowed;
this->normalDistance = normalDistance;
this->extensionDistance = extensionDistance;
}
QDataStream &operator<<(QDataStream& out, const RaceInfo& raceInfo) {
out << raceInfo.numberOfCards;
out << raceInfo.extension;
out << raceInfo.extensionAllowed;
out << raceInfo.normalDistance;
out << raceInfo.extensionDistance;
return out;
}
QDataStream &operator>>(QDataStream& in, RaceInfo& raceInfo) {
in >> raceInfo.numberOfCards;
in >> raceInfo.extension;
in >> raceInfo.extensionAllowed;
in >> raceInfo.normalDistance;
in >> raceInfo.extensionDistance;
return in;
}
QDebug operator<<(QDebug dbg, const RaceInfo &raceInfo) {
dbg.nospace() << raceInfo.numberOfCards << " / " << raceInfo.extension << " " << raceInfo.extensionAllowed << " / " << raceInfo.normalDistance << " " << raceInfo.extensionDistance;
return dbg.space();
}
|
1000-bornes
|
trunk/src/engine/RaceInfo.cpp
|
C++
|
gpl3
| 1,326
|
#include "DiscardPile.h"
DiscardPile::DiscardPile() {}
|
1000-bornes
|
trunk/src/engine/DiscardPile.cpp
|
C++
|
gpl3
| 61
|
#include "Card.h"
QHash<CardID,CardInfo*>* Card::infoHash = NULL;
Card::Card() {}
CardInfo* Card::getInfo(CardID id) {
// Ensures a singleton hash AND that the hash is filled before reading it.
if (infoHash == NULL) createInfoHash();
return infoHash->value(id);
}
CardID Card::cardForProperties(CardFunction function, CardNature nature) {
if (infoHash == NULL) createInfoHash();
foreach (CardID id, infoHash->keys()) {
CardInfo* nfo = infoHash->value(id);
if ((nfo != NULL)
&& (nfo->getFunction() == function)
&& (nfo->getNature() & nature))
return id;
}
return CardID_NoCard;
}
void Card::createInfoHash() {
infoHash = new QHash<CardID,CardInfo*>();
(*infoHash)[CardID_NoCard] =
new CardInfo(tr("[NoCard]"), Properties::FILENAME_CardBack, CardInfo::Function_NoFunction, CardInfo::Nature_NoNature, 0);
(*infoHash)[CardID_Distance_25] =
new CardInfo(tr("25 km"), Properties::FILENAME_Distance_25, CardInfo::Function_Distance, CardInfo::Nature_NoNature, 25);
(*infoHash)[CardID_Distance_50] =
new CardInfo(tr("50 km"), Properties::FILENAME_Distance_50, CardInfo::Function_Distance, CardInfo::Nature_NoNature, 50);
(*infoHash)[CardID_Distance_75] =
new CardInfo(tr("75 km"), Properties::FILENAME_Distance_75, CardInfo::Function_Distance, CardInfo::Nature_NoNature, 75);
(*infoHash)[CardID_Distance_100] =
new CardInfo(tr("100 km"), Properties::FILENAME_Distance_100, CardInfo::Function_Distance, CardInfo::Nature_NoNature, 100);
(*infoHash)[CardID_Distance_200] =
new CardInfo(tr("200 km"), Properties::FILENAME_Distance_200, CardInfo::Function_Distance, CardInfo::Nature_NoNature, 200);
(*infoHash)[CardID_Hazard_Accident] =
new CardInfo(tr("Accident"), Properties::FILENAME_Hazard_Accident, CardInfo::Function_Hazard, CardInfo::Nature_Accident, 0);
(*infoHash)[CardID_Hazard_OutOfGas] =
new CardInfo(tr("Out of Gas"), Properties::FILENAME_Hazard_OutOfGas, CardInfo::Function_Hazard, CardInfo::Nature_Gas, 0);
(*infoHash)[CardID_Hazard_FlatTire] =
new CardInfo(tr("Flat Tire"), Properties::FILENAME_Hazard_FlatTire, CardInfo::Function_Hazard, CardInfo::Nature_Tire, 0);
(*infoHash)[CardID_Hazard_SpeedLimit] =
new CardInfo(tr("Speed Limit"), Properties::FILENAME_Hazard_SpeedLimit, CardInfo::Function_Hazard, CardInfo::Nature_Speed, 0);
(*infoHash)[CardID_Hazard_Stop] =
new CardInfo(tr("Stop"), Properties::FILENAME_Hazard_Stop, CardInfo::Function_Hazard, CardInfo::Nature_Light, 0);
(*infoHash)[CardID_Remedy_Repair] =
new CardInfo(tr("Repairs"), Properties::FILENAME_Remedy_Repair, CardInfo::Function_Remedy, CardInfo::Nature_Accident, 0);
(*infoHash)[CardID_Remedy_Gasoline] =
new CardInfo(tr("Gasoline"), Properties::FILENAME_Remedy_Gasoline, CardInfo::Function_Remedy, CardInfo::Nature_Gas, 0);
(*infoHash)[CardID_Remedy_SpareTire] =
new CardInfo(tr("Spare Tire"), Properties::FILENAME_Remedy_SpareTire, CardInfo::Function_Remedy, CardInfo::Nature_Tire, 0);
(*infoHash)[CardID_Remedy_EndOfLimit] =
new CardInfo(tr("End of Limit"), Properties::FILENAME_Remedy_EndOfLimit, CardInfo::Function_Remedy, CardInfo::Nature_Speed, 0);
(*infoHash)[CardID_Remedy_Roll] =
new CardInfo(tr("Roll"), Properties::FILENAME_Remedy_Roll, CardInfo::Function_Remedy, CardInfo::Nature_Light, 0);
(*infoHash)[CardID_Safety_DrivingAce] =
new CardInfo(tr("Driving Ace"), Properties::FILENAME_Safety_DrivingAce, CardInfo::Function_Safety, CardInfo::Nature_Accident, 0);
(*infoHash)[CardID_Safety_ExtraTank] =
new CardInfo(tr("Extra Tank"), Properties::FILENAME_Safety_ExtraTank, CardInfo::Function_Safety, CardInfo::Nature_Gas, 0);
(*infoHash)[CardID_Safety_PunctureProof] =
new CardInfo(tr("Puncture-proof"), Properties::FILENAME_Safety_PunctureProof, CardInfo::Function_Safety, CardInfo::Nature_Tire, 0);
(*infoHash)[CardID_Safety_RightOfWay] =
new CardInfo(tr("Right of Way"), Properties::FILENAME_Safety_RightOfWay, CardInfo::Function_Safety, CardInfo::Nature_Speed | CardInfo::Nature_Light, 0);
}
|
1000-bornes
|
trunk/src/engine/Card.cpp
|
C++
|
gpl3
| 4,115
|
#ifndef PLAYER_H
#define PLAYER_H
#include "includes.h"
#include "Hand.h"
class Player {
public:
explicit Player(QString name);
QString getName() const;
Hand getHand() const;
private:
QString name;
Hand hand;
};
#endif // PLAYER_H
|
1000-bornes
|
trunk/src/engine/Player.h
|
C++
|
gpl3
| 265
|
#include "DrawPile.h"
DrawPile::DrawPile() {}
|
1000-bornes
|
trunk/src/engine/DrawPile.cpp
|
C++
|
gpl3
| 54
|
#ifndef CARD_H
#define CARD_H
#include "includes.h"
#include "CardInfo.h"
class Card : public QObject {
Q_OBJECT
public:
/* Card unique IDs */
enum ID {
CardID_NoCard,
CardID_Distance_25,
CardID_Distance_50,
CardID_Distance_75,
CardID_Distance_100,
CardID_Distance_200,
CardID_Hazard_Accident,
CardID_Hazard_OutOfGas,
CardID_Hazard_FlatTire,
CardID_Hazard_SpeedLimit,
CardID_Hazard_Stop,
CardID_Remedy_Repair,
CardID_Remedy_Gasoline,
CardID_Remedy_SpareTire,
CardID_Remedy_EndOfLimit,
CardID_Remedy_Roll,
CardID_Safety_DrivingAce,
CardID_Safety_ExtraTank,
CardID_Safety_PunctureProof,
CardID_Safety_RightOfWay
};
typedef ID CardID;
static CardInfo* getInfo(CardID id);
static CardID cardForProperties(CardFunction function, CardNature nature);
private:
explicit Card();
static QHash<CardID,CardInfo*>* infoHash;
static void createInfoHash();
};
typedef Card::ID CardID;
#endif // CARD_H
|
1000-bornes
|
trunk/src/engine/Card.h
|
C++
|
gpl3
| 1,038
|
#include "CardInfo.h"
CardInfo::CardInfo(QString name, QString filename, CardFunction function, CardNature nature, int distance) {
this->name = name;
this->filename = filename;
this->function = function;
this->nature = nature;
this->distance = distance;
}
QString CardInfo::getName() const {
return name;
}
QString CardInfo::getFilename() const {
return filename;
}
CardFunction CardInfo::getFunction() const {
return function;
}
CardNature CardInfo::getNature() const {
return nature;
}
int CardInfo::getDistance() const {
return distance;
}
|
1000-bornes
|
trunk/src/engine/CardInfo.cpp
|
C++
|
gpl3
| 590
|
#ifndef RACEINFO_H
#define RACEINFO_H
#include "includes.h"
class RaceInfo : public QObject {
Q_OBJECT
public:
RaceInfo();
RaceInfo(int numberOfCard, bool extension, bool extensionAllowed, int normalDistance, int extensionDistance);
public:
int numberOfCards;
bool extension;
bool extensionAllowed;
int normalDistance;
int extensionDistance;
};
/* Serialization */
QDataStream &operator<<(QDataStream& out, const RaceInfo& raceInfo);
QDataStream &operator>>(QDataStream& in, RaceInfo& raceInfo);
QDebug operator<<(QDebug dbg, const RaceInfo &raceInfo);
#endif // RACEINFO_H
|
1000-bornes
|
trunk/src/engine/RaceInfo.h
|
C++
|
gpl3
| 629
|
#ifndef TEAM_H
#define TEAM_H
#include "includes.h"
#include "Player.h"
#include "Tableau.h"
class Tableau;
class Player;
class Team : public QList<Player*> {
public:
Team();
~Team();
Tableau* getTableau();
void addPlayer(Player* player);
private:
Tableau* tableau;
};
#endif // TEAM_H
|
1000-bornes
|
trunk/src/engine/Team.h
|
C++
|
gpl3
| 334
|
#include "Hand.h"
Hand::Hand() {}
|
1000-bornes
|
trunk/src/engine/Hand.cpp
|
C++
|
gpl3
| 40
|
#ifndef TABLEAU_H
#define TABLEAU_H
#include "includes.h"
#include "Team.h"
#include "Player.h"
#include "Card.h"
#include "CardInfo.h"
class Team;
/*$this->pileVitesse = array();
$this->pileCombat = array();
$this->pile200 = array();
$this->pile100 = array();
$this->pile75 = array();
$this->pile50 = array();
$this->pile25 = array();
$this->botteCiterne = NULL;
$this->botteIncreuvable = NULL;
$this->botteAsVolant = NULL;
$this->bottePrioritaire = NULL;*/
class Tableau {
public:
explicit Tableau(Team* owningTeam);
~Tableau();
Team* getOwningTeam() { return owningTeam; }
void setWinDistance(int winDistance) { this->winDistance = winDistance; }
int numberOf200() const;
int distance() const;
bool canPlay(Player* player, CardID card) const;
QList<CardID> play(CardID card, bool coupFourre = false);
bool canRoll() const;
int canRollDistance() const;
int points();
public:
QList<CardID> battlePile;
QList<CardID> speedPile;
QList<CardID> distanceArea;
QHash<CardID,bool> safetyArea;
private:
Team* owningTeam;
int winDistance; // 700 or 1000 km
};
QDebug operator<<(QDebug dbg, const Tableau &tab);
#endif // TABLEAU_H
|
1000-bornes
|
trunk/src/engine/Tableau.h
|
C++
|
gpl3
| 1,262
|