NS_SERVICE_INFOW

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct BLOB
{
    public uint cbSize;
    public IntPtr pBlobData;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SERVICE_INFOW
{
    public IntPtr lpServiceType;
    public IntPtr lpServiceName;
    public IntPtr lpComment;
    public IntPtr lpLocale;
    public uint dwDisplayHint;
    public uint dwVersion;
    public uint dwTime;
    public IntPtr lpMachineName;
    public IntPtr lpServiceAddress;
    public BLOB ServiceSpecificInfo;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct NS_SERVICE_INFOW
{
    public uint dwNameSpace;
    public SERVICE_INFOW ServiceInfo;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure BLOB
    Public cbSize As UInteger
    Public pBlobData As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SERVICE_INFOW
    Public lpServiceType As IntPtr
    Public lpServiceName As IntPtr
    Public lpComment As IntPtr
    Public lpLocale As IntPtr
    Public dwDisplayHint As UInteger
    Public dwVersion As UInteger
    Public dwTime As UInteger
    Public lpMachineName As IntPtr
    Public lpServiceAddress As IntPtr
    Public ServiceSpecificInfo As BLOB
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure NS_SERVICE_INFOW
    Public dwNameSpace As UInteger
    Public ServiceInfo As SERVICE_INFOW
End Structure

import ctypes
from ctypes import wintypes

class BLOB(ctypes.Structure):
    _fields_ = [
        ("cbSize", wintypes.DWORD),
        ("pBlobData", ctypes.c_void_p),
    ]

class SERVICE_INFOW(ctypes.Structure):
    _fields_ = [
        ("lpServiceType", ctypes.c_void_p),
        ("lpServiceName", ctypes.c_void_p),
        ("lpComment", ctypes.c_void_p),
        ("lpLocale", ctypes.c_void_p),
        ("dwDisplayHint", wintypes.DWORD),
        ("dwVersion", wintypes.DWORD),
        ("dwTime", wintypes.DWORD),
        ("lpMachineName", ctypes.c_void_p),
        ("lpServiceAddress", ctypes.c_void_p),
        ("ServiceSpecificInfo", BLOB),
    ]

class NS_SERVICE_INFOW(ctypes.Structure):
    _fields_ = [
        ("dwNameSpace", wintypes.DWORD),
        ("ServiceInfo", SERVICE_INFOW),
    ]

#[repr(C)]
pub struct BLOB {
    pub cbSize: u32,
    pub pBlobData: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct SERVICE_INFOW {
    pub lpServiceType: *mut core::ffi::c_void,
    pub lpServiceName: *mut core::ffi::c_void,
    pub lpComment: *mut core::ffi::c_void,
    pub lpLocale: *mut core::ffi::c_void,
    pub dwDisplayHint: u32,
    pub dwVersion: u32,
    pub dwTime: u32,
    pub lpMachineName: *mut core::ffi::c_void,
    pub lpServiceAddress: *mut core::ffi::c_void,
    pub ServiceSpecificInfo: BLOB,
}

#[repr(C)]
pub struct NS_SERVICE_INFOW {
    pub dwNameSpace: u32,
    pub ServiceInfo: SERVICE_INFOW,
}

import "golang.org/x/sys/windows"

type BLOB struct {
	cbSize uint32
	pBlobData uintptr
}

type SERVICE_INFOW struct {
	lpServiceType uintptr
	lpServiceName uintptr
	lpComment uintptr
	lpLocale uintptr
	dwDisplayHint uint32
	dwVersion uint32
	dwTime uint32
	lpMachineName uintptr
	lpServiceAddress uintptr
	ServiceSpecificInfo BLOB
}

type NS_SERVICE_INFOW struct {
	dwNameSpace uint32
	ServiceInfo SERVICE_INFOW
}

type
  BLOB = record
    cbSize: DWORD;
    pBlobData: Pointer;
  end;

  SERVICE_INFOW = record
    lpServiceType: Pointer;
    lpServiceName: Pointer;
    lpComment: Pointer;
    lpLocale: Pointer;
    dwDisplayHint: DWORD;
    dwVersion: DWORD;
    dwTime: DWORD;
    lpMachineName: Pointer;
    lpServiceAddress: Pointer;
    ServiceSpecificInfo: BLOB;
  end;

  NS_SERVICE_INFOW = record
    dwNameSpace: DWORD;
    ServiceInfo: SERVICE_INFOW;
  end;

const BLOB = extern struct {
    cbSize: u32,
    pBlobData: ?*anyopaque,
};

const SERVICE_INFOW = extern struct {
    lpServiceType: ?*anyopaque,
    lpServiceName: ?*anyopaque,
    lpComment: ?*anyopaque,
    lpLocale: ?*anyopaque,
    dwDisplayHint: u32,
    dwVersion: u32,
    dwTime: u32,
    lpMachineName: ?*anyopaque,
    lpServiceAddress: ?*anyopaque,
    ServiceSpecificInfo: BLOB,
};

const NS_SERVICE_INFOW = extern struct {
    dwNameSpace: u32,
    ServiceInfo: SERVICE_INFOW,
};

type
  BLOB {.bycopy.} = object
    cbSize: uint32
    pBlobData: pointer

  SERVICE_INFOW {.bycopy.} = object
    lpServiceType: pointer
    lpServiceName: pointer
    lpComment: pointer
    lpLocale: pointer
    dwDisplayHint: uint32
    dwVersion: uint32
    dwTime: uint32
    lpMachineName: pointer
    lpServiceAddress: pointer
    ServiceSpecificInfo: BLOB

  NS_SERVICE_INFOW {.bycopy.} = object
    dwNameSpace: uint32
    ServiceInfo: SERVICE_INFOW

struct BLOB
{
    uint cbSize;
    void* pBlobData;
}

struct SERVICE_INFOW
{
    void* lpServiceType;
    void* lpServiceName;
    void* lpComment;
    void* lpLocale;
    uint dwDisplayHint;
    uint dwVersion;
    uint dwTime;
    void* lpMachineName;
    void* lpServiceAddress;
    BLOB ServiceSpecificInfo;
}

struct NS_SERVICE_INFOW
{
    uint dwNameSpace;
    SERVICE_INFOW ServiceInfo;
}