标签: unsafe

我有一个MMORPG模拟器,这意味着它将处理相当多的数据包.目前,我正在使用指针,因为我认为正确使用它们可以加快我的服务器,但是我有两个朋友,一个告诉我使用指针,他认为我可以使用它们而不会遇到麻烦,我的其他朋友说我不应该使用指针,因为它们可能会使我的服务器崩溃,它们不安全,并且它们不易管理.

我使用结构作为我的数据包结构,所以例如我可以使用以下行获取它的类型:Ptr-> Type;

你怎么看？

我来自C++背景.在C++中,我可以存储一个内存地址,我刚刚在全局数组中新建,并在以后重新使用它.例如,假设我有两个类X,Y和我创建两个对象x,y.全局数组StoreAddresses [2]定义为:

 uint32_t StoreAddresses[2];

我写:

 X * x = new X();
 Y * y = new Y();
 StoreAdresses[0] = (uint32t *) x; //for example, 0x12345678
 StoreAdresses[1] = (uint32t *) y; //for example, 0x12345698

在我的程序中的任何地方,我都可以通过调用来检索内存中写入的数据:

 X * stored_x = (X*)StoreAdresses[0];
 Y * stored_y = (Y*)StoreAdresses[1];

我怎样才能在Java中实现这一目标？感谢帮助!

我试图使用sun.misc.Unsafe.allocateMemory()分配内存并在本机代码中访问它.

但是,似乎allocateMemory返回的long值在C代码中不能作为正确的地址.

            Unsafe unsafe = getUnsafe();
            long address = unsafe.allocateMemory(64);

            for (int i = 0; i < 64; i += 8)
                unsafe.putByte(memory + i, (byte) 0xFF);

            nativeMethod(address);

但是在我的本机代码中,当我尝试将"地址"作为指针访问时,它不起作用:(

更新:我附上了一张显示问题的图片.我将'地址'传递给本机代码,然而,检​​查该位置的内存并没有显示我放在那里的0xFF值.

图片: http ://i.stack.imgur.com/KoIYG.png

在一个unsafe块中,我正在尝试获取指向byte数组的指针.但是根据声明的数组大小,我会得到不同的结果:

unsafe {

    byte[] bytes;

    bytes = new byte[1];
    fixed(void* pBytes = bytes)
    {
        ((int)pBytes).Dump(); //prints e.g. 41797644
    }

    bytes = new byte[0];
    fixed(void* pBytes = bytes)
    {
        ((int)pBytes).Dump(); //prints 0 ?!
    }
}

如果我打开立即窗口并键入&bytes,我得到字节数组的实际地址,包括空数组的情况.

为什么fixed非托管指针的工作原理不一样？

更新:

这是相同的代码以及我从即时窗口获得的代码:

unsafe {
    byte[] bytes;
    bytes = new byte[1];
    fixed(void* pBytes = bytes)
    {
                       // bytes => 
                       // {byte[1]}
                       //    [0]: 0
                       //
                       // &bytes
                       // 0x0601c34c               //the address of the variable
                       //    bytes: 0x027dc804 …

我想知道Marshal.GetFunctionPointerForDelegate.即我想知道它如何将委托转换为非静态函数到函数指针.

它是否动态生成以某种方式附加实例的代码存根？如果是这样,这不是泄密记忆吗？也许代表在终结器中解放了它？

它看起来不像System.Delegate有一个终结器,所以我对这个机制的工作原理非常感兴趣.我假设函数指针需要4个字节,实例需要4个字节(32位),但它返回一个简单的IntPtr.

我试图了解如何从以下结构中的不安全字节指针获取字符串。SDL_TEXTINPUTEVENT_TEXTSIZE 是 32。

[StructLayout(LayoutKind.Sequential)]
public unsafe struct SDL_TextInputEvent
{
    public SDL_EventType type;
    public UInt32 timestamp;
    public UInt32 windowID;
    public fixed byte text[SDL_TEXTINPUTEVENT_TEXT_SIZE];
}

我试过了：

byte[] rawBytes = new byte[SDL_TEXTINPUTEVENT_TEXT_SIZE];

unsafe
{
    Marshal.Copy((IntPtr)rawEvent.text.text, rawBytes, 0, SDL_TEXTINPUTEVENT_TEXT_SIZE);
}

string text = System.Text.Encoding.UTF8.GetString(rawBytes);

哪种有效，但给了我一个字符串，除了实际输入的字符之外，还有很多额外的字节。我应该解析字节数组并搜索以 0 结尾的字符以避免多余的字符吗？

我完全误解了什么吗？

作为参考，被编组到 .NET 运行时的原始 C 结构是：

typedef struct SDL_TextInputEvent
{
    Uint32 type;
    Uint32 timestamp;
    Uint32 windowID;
    char text[SDL_TEXTINPUTEVENT_TEXT_SIZE];
} SDL_TextInputEvent;

[]byte转换为的首选方式string是：

var b []byte
// fill b
s := string(b)

在此代码中复制字节片，这在性能很重要的情况下可能会出现问题。

当性能至关重要时，可以考虑执行不安全转换：

var b []byte
// fill b
s :=  *(*string)(unsafe.Pointer(&b))

我的问题是：使用不安全转换时会出现什么问题？我知道这string应该是不可变的，如果我们改变b，s它也会改变。但仍然：那又怎样？难道这一切都可能发生吗？

在C#中,我写道

unsafe void Main() {
  float f = 3.14f;
  int i = *(int*)&f;
}

是否可以将此代码转换为F#？

我的理解是指针是由nativeptr<'a>类型表示的,但我对于我的生活我找不到相当于地址引用&和指针解引用的*运算符.我怀疑 NativePtr.get可能是后者,但它的实现逃脱了我,因为我不太了解IL.

我知道BitConverter和Marshal,但我正在寻找一种方法来实现位修改而不复制内存.

这是我尝试在我的 java web 应用程序中发送带有 URL 的 GET 请求时的错误：我的本地机器 url 看起来像这样http://localhost:8080/test?param1=1|2¶m2=3343434

2017 年 2 月 20 日下午 4:51:19 org.apache.coyote.http11.AbstractHttp11Processor 进程信息：解析 HTTP 请求标头时出错 注意：进一步发生的 HTTP 标头解析错误将在调试级别记录。java.lang.IllegalArgumentException: 在请求目标中发现无效字符。有效字符在 org.apache.coyote.http11.AbstractNioInputBuffer.parseRequestLine(AbstractNioInputBuffer.java:283) 处 org.apache.coyote.http11.AbstractHttp11Processor.process(AbstractHttp11Processor.java:10) 处的 RFC 7230 和 RFC 3986 中定义org.apache.coyote.AbstractProtocol$AbstractConnectionHandler.process(AbstractProtocol.java:684) 在 org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1524) 在 org.apache.tomcat.util。 net.NioEndpoint$SocketProcessor.run(NioEndpoint.java:

我想问一下是否可以在不更改 Apache Tomcat 版本或更改现有代码的情况下解决此问题。我想知道 Apache Tomcat 配置文件是否能够禁用或绕过此检查？

我有一个包含不安全代码的结构，其方法如下：

use std::sync::Arc;
use std::thread;

#[derive(Debug)]
struct Foo<T> {
    items: Vec<Box<(T, String)>>,
}

impl<T> Foo<T> {
    pub fn add_element(&self, element: T, key: String) {
        if !(self.items.iter().any( |i| i.1 == key)) {
            let mut items = unsafe {change_mut(&(self.items))};
            items.push(Box::new((element,key)));
        }
    }
}

unsafe fn change_mut<T>(x: &T) -> &mut T { // changes &self to &mut self
    &mut *(x as *const T as *mut T)
}

fn main() {
    let foo = Arc::new(Foo { items: vec!() });
    let clone = foo.clone();

    // …