NS_SERVICE_INFOA

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_INFOA
{
    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_INFOA
{
    public uint dwNameSpace;
    public SERVICE_INFOA 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_INFOA
    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_INFOA
    Public dwNameSpace As UInteger
    Public ServiceInfo As SERVICE_INFOA
End Structure

import ctypes
from ctypes import wintypes

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

class SERVICE_INFOA(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_INFOA(ctypes.Structure):
    _fields_ = [
        ("dwNameSpace", wintypes.DWORD),
        ("ServiceInfo", SERVICE_INFOA),
    ]

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

#[repr(C)]
pub struct SERVICE_INFOA {
    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_INFOA {
    pub dwNameSpace: u32,
    pub ServiceInfo: SERVICE_INFOA,
}

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

type BLOB struct {
	cbSize uint32
	pBlobData uintptr
}

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

type NS_SERVICE_INFOA struct {
	dwNameSpace uint32
	ServiceInfo SERVICE_INFOA
}

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

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

  NS_SERVICE_INFOA = record
    dwNameSpace: DWORD;
    ServiceInfo: SERVICE_INFOA;
  end;

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

const SERVICE_INFOA = 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_INFOA = extern struct {
    dwNameSpace: u32,
    ServiceInfo: SERVICE_INFOA,
};

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

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

  NS_SERVICE_INFOA {.bycopy.} = object
    dwNameSpace: uint32
    ServiceInfo: SERVICE_INFOA

struct BLOB
{
    uint cbSize;
    void* pBlobData;
}

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

struct NS_SERVICE_INFOA
{
    uint dwNameSpace;
    SERVICE_INFOA ServiceInfo;
}