kNetwork.h

Go to the documentation of this file.

#ifndef K_API_NETWORK_H
#define K_API_NETWORK_H

#include <kApi/kApiDef.h>
#include <kApi/Data/kString.h>

typedef k32s kIpVersion; 

#define kIP_VERSION_4          (4)         

typedef k32s kIpAssignment; 

#define kIP_ASSIGNMENT_UNKNOWN      (0)    
#define kIP_ASSIGNMENT_AUTOMATIC    (1)    
#define kIP_ASSIGNMENT_MANUAL       (2)    

typedef xkNetworkInfoFilter kNetworkAdapterType; 

#define kNETWORK_ADAPTER_ETHERNET                   (0x0001)    
#define kNETWORK_ADAPTER_LOOPBACK                   (0x0002)    
#define kNETWORK_ADAPTER_OTHER                      (0x0800)    
#define kNETWORK_ADAPTER_OPTIONS                    (0xFFFF)    
#define kNETWORK_ADAPTER_TYPE_FILTER_DEFAULT        kNETWORK_ADAPTER_OPTIONS
#define kNETWORK_ADAPTER_TYPE_FILTER_NO_LOOPBACK    (kNETWORK_ADAPTER_OPTIONS & ~kNETWORK_ADAPTER_LOOPBACK)

typedef xkNetworkInfoFilter kNetworkAdapterState; 

#define kNETWORK_ADAPTER_STATE_DISABLED             (0x0001)    
#define kNETWORK_ADAPTER_STATE_ENABLED              (0x0002)    
#define kNETWORK_ADAPTER_STATE_OPTIONS              (0x0003)    
#define kNETWORK_ADAPTER_STATE_FILTER_DEFAULT       kNETWORK_ADAPTER_STATE_ENABLED

typedef struct kIpAddress
{
    kIpVersion version;                 
    kByte address[16];                  
} kIpAddress;                                 

kFx(kIpAddress) kIpAddress_Any(kIpVersion version); 

kFx(kIpAddress) kIpAddress_AnyV4(); 

kFx(kIpAddress) kIpAddress_BroadcastV4();

kFx(kIpAddress) kIpAddress_Loopback(kIpVersion version);

kFx(kIpAddress) kIpAddress_LoopbackV4();

kFx(kStatus) kIpAddress_Parse(kIpAddress* address, const kChar* text); 

kFx(kStatus) kIpAddress_Format(kIpAddress address, kChar* text, kSize capacity); 

kFx(kBool) kIpAddress_Equals(kIpAddress a, kIpAddress b); 

kFx(kBool) kIpAddress_IsLoopback(kIpAddress address); 

kFx(kBool) kIpAddress_IsLinkLocal(kIpAddress address); 

kFx(k32u) kIpAddress_ToHost32u(kIpAddress address); 

kFx(k32u) kIpAddress_ToNet32u(kIpAddress address); 

kFx(kIpAddress) kIpAddress_FromHost32u(k32u address); 

kFx(kIpAddress) kIpAddress_FromNet32u(k32u address); 

kFx(kIpAddress) kIpAddress_Network(kIpAddress address, k32u prefixLength); 

kFx(kBool) kIpAddress_NetworkEquals(kIpAddress a, kIpAddress b, k32u prefixLength); 

typedef struct kIpEndPoint              
{
    kIpAddress address;         
    k32u port;                  
} kIpEndPoint;                  

#define kIP_PORT_ANY    (0)     

#include <kApi/Io/kNetwork.x.h>

//typedef kObject kNetworkInterface;        --forward-declared in kApiDef.x.h 

kInlineFx(kNetworkAdapter) kNetworkInterface_Adapter(kNetworkInterface iface)
{
    kObj(kNetworkInterface, iface);
    return obj->adapter; 
}

kInlineFx(kIpAddress) kNetworkInterface_Address(kNetworkInterface iface)
{
    kObj(kNetworkInterface, iface);
    return obj->address; 
}

kInlineFx(k32u) kNetworkInterface_PrefixLength(kNetworkInterface iface)
{
    kObj(kNetworkInterface, iface);
    return obj->prefixLength; 
}

//typedef kObject kNetworkAdapter;        --forward-declared in kApiDef.x.h 

kInlineFx(kNetworkInfo) kNetworkAdapter_Info(kNetworkAdapter adapter)
{
    kObj(kNetworkAdapter, adapter);
    return obj->info; 
}

kInlineFx(const kChar*) kNetworkAdapter_Name(kNetworkAdapter adapter)
{
    kObj(kNetworkAdapter, adapter);
    return kString_Chars(obj->name); 
}

kInlineFx(kSize) kNetworkAdapter_Id(kNetworkAdapter adapter)
{
    kObj(kNetworkAdapter, adapter);
    return obj->id; 
}

kInlineFx(kBool) kNetworkAdapter_IsEnabled(kNetworkAdapter adapter)
{
    kObj(kNetworkAdapter, adapter);
    return obj->isEnabled; 
}

kInlineFx(kBool) kNetworkAdapter_IsLinkRunning(kNetworkAdapter adapter)
{
    kObj(kNetworkAdapter, adapter);
    return obj->isLinkRunning; 
}

kInlineFx(kNetworkAdapterType) kNetworkAdapter_Type(kNetworkAdapter adapter)
{
    kObj(kNetworkAdapter, adapter);
    return obj->adapterType; 
}

kInlineFx(kMacAddress) kNetworkAdapter_MacAddress(kNetworkAdapter adapter)
{
    kObj(kNetworkAdapter, adapter);
    return obj->macAddress; 
}

kInlineFx(kIpAssignment) kNetworkAdapter_IpAssignment(kNetworkAdapter adapter)
{
    kObj(kNetworkAdapter, adapter);
    return obj->ipAssignment; 
}

kInlineFx(kSize) kNetworkAdapter_InterfaceCount(kNetworkAdapter adapter)
{
    kObj(kNetworkAdapter, adapter);
    return kArrayList_Count(obj->interfaces);
}

kInlineFx(kNetworkInterface) kNetworkAdapter_InterfaceAt(kNetworkAdapter adapter, kSize index)
{
    kObj(kNetworkAdapter, adapter);
    return kArrayList_AsT(obj->interfaces, index, kNetworkInterface);
}

kInlineFx(kStatus) kNetworkAdapter_InterfaceItem(kNetworkAdapter adapter, kSize index, kNetworkInterface* iface)
{
    kObj(kNetworkAdapter, adapter);
    return kArrayList_ItemT(obj->interfaces, index, iface);
}

//typedef kObject kNetworkInfo;        --forward-declared in kApiDef.x.h 

kInlineFx(kStatus) kNetworkInfo_Construct(kNetworkInfo* info, kAlloc alloc)
{
    return kNetworkInfo_ConstructEx(info, kNETWORK_ADAPTER_TYPE_FILTER_DEFAULT, kNETWORK_ADAPTER_STATE_FILTER_DEFAULT, alloc);
}

#if defined(K_CPP)

kInlineFx(kStatus) kNetworkInfo_Construct(kNetworkInfo* info, kNetworkAdapterType typeFilter, kNetworkAdapterState stateFilter, kAlloc alloc)
{
    return kNetworkInfo_ConstructEx(info, typeFilter, stateFilter, alloc);
}
#endif

kFx(kStatus) kNetworkInfo_Refresh(kNetworkInfo info); 

kInlineFx(kSize) kNetworkInfo_AdapterCount(kNetworkInfo info)
{
    kObj(kNetworkInfo, info);
    return kArrayList_Count(obj->adapters);
}

kInlineFx(kNetworkAdapter) kNetworkInfo_AdapterAt(kNetworkInfo info, kSize index)
{
    kObj(kNetworkInfo, info);
    return kArrayList_AsT(obj->adapters, index, kNetworkAdapter);
}

kInlineFx(kSize) kNetworkInfo_InterfaceCount(kNetworkInfo info)
{
    kObj(kNetworkInfo, info);
    return kArrayList_Count(obj->interfaces);
}

kInlineFx(kNetworkInterface) kNetworkInfo_InterfaceAt(kNetworkInfo info, kSize index)
{
    kObj(kNetworkInfo, info);
    return kArrayList_AsT(obj->interfaces, index, kNetworkInterface);
}

kFx(kStatus) kNetworkInfo_FindAdapterByName(kNetworkInfo info, const kChar* name, kNetworkAdapter* adapter); 

kFx(kStatus) kNetworkInfo_FindAdapterById(kNetworkInfo info, kSize id, kNetworkAdapter* adapter); 

kFx(kStatus) kNetworkInfo_FindInterfaceByAddress(kNetworkInfo info, kIpAddress address, kNetworkInterface* iface); 

kFx(kStatus) kNetworkInfo_FindInterfaceByNetwork(kNetworkInfo info, kIpAddress address, kNetworkInterface* iface); 

//typedef kObject kNetwork;        --forward-declared in kApiDef.x.h 

kFx(kStatus) kNetwork_AddChangeHandler(kCallbackFx function, kPointer receiver); 

kFx(kStatus) kNetwork_RemoveChangeHandler(kCallbackFx function, kPointer receiver); 

kFx(kStatus) kNetwork_FindAdapterNameById(kSize adapterId, kChar* adapterName, kSize adapterNameCapacity);

kFx(kStatus) kNetwork_FindAdapterIdByName(const kChar* adapterName, kSize* adapterId);

kFx(kStatus) kNetwork_FindAdapterNameByInterface(kIpAddress interfaceAddress, kChar* adapterName, kSize adapterNameCapacity); 

kFx(kStatus) kNetwork_FindMacAdressByInterface(kIpAddress interfaceAddress, kMacAddress* macAddress);

kFx(kStatus) kNetwork_FindFirstAdapterInterface(const kChar* adapterName, kIpAddress* interfaceAddress); 

kFx(kStatus) kNetwork_FindInterfaceByNetwork(kIpAddress network, kIpAddress* interfaceAddress); 

#endif