BodgeMaster
/
NORM-mirror
mirror of https://github.com/USNavalResearchLaboratory/norm.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

pynorm fixes

pull/72/head
Brian Adamson 2022-08-20 22:36:29 -04:00
parent a1bb33c354
commit 001d50aa46
224 changed files with 246 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
.github/workflows/cmake.yml vendored Normal file → Executable file
View File

0
.gitignore vendored Normal file → Executable file
View File

0
.gitmodules vendored Normal file → Executable file
View File

0
BUILD.TXT Normal file → Executable file
View File

0
CMakeLists.txt Normal file → Executable file
View File

0
Dockerfile Normal file → Executable file
View File

0
LICENSE Normal file → Executable file
View File

0
NormSocketBindingNotes.txt Normal file → Executable file
View File

0
README-Java.txt Normal file → Executable file
View File

0
README-PyNorm.txt Normal file → Executable file
View File

0
README.md Normal file → Executable file
View File

0
TODO.TXT Normal file → Executable file
View File

0
VERSION.TXT Normal file → Executable file
View File

0
android/README.md Normal file → Executable file
View File

0
android/build.gradle Normal file → Executable file
View File

0
android/gradle/wrapper/LICENSE-for-gradlewrapper.txt vendored Normal file → Executable file
View File

0
android/gradle/wrapper/gradle-wrapper.jar vendored Normal file → Executable file
View File

0
android/gradle/wrapper/gradle-wrapper.properties vendored Normal file → Executable file
View File

0
android/gradlew.bat vendored Normal file → Executable file
View File

0
android/lib/CMakeLists.txt Normal file → Executable file
View File

0
android/lib/build.gradle Normal file → Executable file
View File

0
android/lib/src/main/AndroidManifest.xml Normal file → Executable file
View File

0
android/settings.gradle Normal file → Executable file
View File

0
cmake/normConfig.cmake.in Normal file → Executable file
View File

0
doc/NormDeveloperGuide.html Normal file → Executable file
View File

0
doc/NormDeveloperGuide.pdf Normal file → Executable file
View File

0
doc/NormDeveloperGuide.xml Normal file → Executable file
View File

0
doc/NormLogo.gif Normal file → Executable file
View File

Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 12 KiB

After

Width:  |  Height:  |  Size: 12 KiB

0
doc/NormUserGuide.pdf Normal file → Executable file
View File

0
doc/NormUserGuide.xml Normal file → Executable file
View File

0
doc/npcUsage.pdf Normal file → Executable file
View File

0
examples/README.TXT Normal file → Executable file
View File

0
examples/java/NormFileRecv.java Normal file → Executable file
View File

0
examples/java/NormFileSend.java Normal file → Executable file
View File

0
examples/java/NormFileSendRecv.java Normal file → Executable file
View File

0
examples/java/NormMsgr.java Normal file → Executable file
View File

0
examples/java/NormStreamRecv.java Normal file → Executable file
View File

0
examples/java/NormStreamSend.java Normal file → Executable file
View File

0
examples/java/README.TXT Normal file → Executable file
View File

0
examples/normCast.cpp Normal file → Executable file
View File

0
examples/normCastApp.cpp Normal file → Executable file
View File

0
examples/normClient.cpp Normal file → Executable file
View File

0
examples/normDataExample.cpp Normal file → Executable file
View File

0
examples/normDataRecv.cpp Normal file → Executable file
View File

0
examples/normDataSend.cpp Normal file → Executable file
View File

0
examples/normFileRecv.cpp Normal file → Executable file
View File

0
examples/normFileSend.cpp Normal file → Executable file
View File

0
examples/normMsgr.cpp Normal file → Executable file
View File

0
examples/normServer.cpp Normal file → Executable file
View File

0
examples/normSocket.cpp Normal file → Executable file
View File

0
examples/normSocket.h Normal file → Executable file
View File

0
examples/normSocketNotes.txt Normal file → Executable file
View File

0
examples/normStreamRecv.cpp Normal file → Executable file
View File

0
examples/normStreamSend.cpp Normal file → Executable file
View File

0
examples/normStreamer.cpp Normal file → Executable file
View File

0
examples/python/normMsgr.py Normal file → Executable file
View File

0
examples/win32InputHandler.cpp Normal file → Executable file
View File

0
examples/wintest.cpp Normal file → Executable file
View File

0
include/galois.h Normal file → Executable file
View File

285
include/normApi.h Normal file → Executable file
View File

@ -77,7 +77,7 @@ const NormSessionHandle NORM_SESSION_INVALID;
typedef UINT16 NormSessionId; typedef UINT16 NormSessionId;
typedef const void* NormNodeHandle; typedef const void* NormNodeHandle;
extern NORM_API_LINKAGE extern NORM_API_LINKAGE
const NormNodeHandle NORM_NODE_INVALID; const NormNodeHandle NORM_NODE_INVALID;
typedef UINT32 NormNodeId; typedef UINT32 NormNodeId;
extern NORM_API_LINKAGE extern NORM_API_LINKAGE
@ -101,21 +101,21 @@ typedef enum NormObjectType
NORM_OBJECT_NONE, NORM_OBJECT_NONE,
NORM_OBJECT_DATA, NORM_OBJECT_DATA,
NORM_OBJECT_FILE, NORM_OBJECT_FILE,
NORM_OBJECT_STREAM NORM_OBJECT_STREAM
} NORM_API_LINKAGE NormObjectType; } NORM_API_LINKAGE NormObjectType;
typedef enum NormFlushMode typedef enum NormFlushMode
{ {
NORM_FLUSH_NONE, NORM_FLUSH_NONE,
NORM_FLUSH_PASSIVE, NORM_FLUSH_PASSIVE,
NORM_FLUSH_ACTIVE NORM_FLUSH_ACTIVE
} NORM_API_LINKAGE NormFlushMode; } NORM_API_LINKAGE NormFlushMode;
typedef enum NormNackingMode typedef enum NormNackingMode
{ {
NORM_NACK_NONE, NORM_NACK_NONE,
NORM_NACK_INFO_ONLY, NORM_NACK_INFO_ONLY,
NORM_NACK_NORMAL NORM_NACK_NORMAL
} NORM_API_LINKAGE NormNackingMode; } NORM_API_LINKAGE NormNackingMode;
typedef enum NormAckingStatus typedef enum NormAckingStatus
@ -123,38 +123,38 @@ typedef enum NormAckingStatus
NORM_ACK_INVALID, NORM_ACK_INVALID,
NORM_ACK_FAILURE, NORM_ACK_FAILURE,
NORM_ACK_PENDING, NORM_ACK_PENDING,
NORM_ACK_SUCCESS NORM_ACK_SUCCESS
} NORM_API_LINKAGE NormAckingStatus; } NORM_API_LINKAGE NormAckingStatus;
typedef enum NormTrackingStatus typedef enum NormTrackingStatus
{ {
NORM_TRACK_NONE, NORM_TRACK_NONE,
NORM_TRACK_RECEIVERS, NORM_TRACK_RECEIVERS,
NORM_TRACK_SENDERS, NORM_TRACK_SENDERS,
NORM_TRACK_ALL NORM_TRACK_ALL
} NORM_API_LINKAGE NormTrackingStatus; } NORM_API_LINKAGE NormTrackingStatus;
typedef enum NormProbingMode typedef enum NormProbingMode
{ {
NORM_PROBE_NONE, NORM_PROBE_NONE,
NORM_PROBE_PASSIVE, NORM_PROBE_PASSIVE,
NORM_PROBE_ACTIVE NORM_PROBE_ACTIVE
} NORM_API_LINKAGE NormProbingMode; } NORM_API_LINKAGE NormProbingMode;
typedef enum NormSyncPolicy typedef enum NormSyncPolicy
{ {
NORM_SYNC_CURRENT, // attempt to receiver current/new objects only, join mid-stream NORM_SYNC_CURRENT, // attempt to receiver current/new objects only, join mid-stream
NORM_SYNC_STREAM, // sync to current stream, but to beginning of stream NORM_SYNC_STREAM, // sync to current stream, but to beginning of stream
NORM_SYNC_ALL // attempt to receive old and new objects NORM_SYNC_ALL // attempt to receive old and new objects
} NORM_API_LINKAGE NormSyncPolicy; } NORM_API_LINKAGE NormSyncPolicy;
typedef enum NormRepairBoundary typedef enum NormRepairBoundary
{ {
NORM_BOUNDARY_BLOCK, NORM_BOUNDARY_BLOCK,
NORM_BOUNDARY_OBJECT NORM_BOUNDARY_OBJECT
} NORM_API_LINKAGE NormRepairBoundary; } NORM_API_LINKAGE NormRepairBoundary;
typedef enum NormEventType typedef enum NormEventType
{ {
NORM_EVENT_INVALID = 0, NORM_EVENT_INVALID = 0,
@ -183,7 +183,7 @@ typedef enum NormEventType
NORM_GRTT_UPDATED, NORM_GRTT_UPDATED,
NORM_CC_ACTIVE, NORM_CC_ACTIVE,
NORM_CC_INACTIVE, NORM_CC_INACTIVE,
NORM_ACKING_NODE_NEW, // whe NormSetAutoAcking NORM_ACKING_NODE_NEW, // whe NormSetAutoAcking
NORM_SEND_ERROR, // ICMP error (e.g. destination unreachable) NORM_SEND_ERROR, // ICMP error (e.g. destination unreachable)
NORM_USER_TIMEOUT // issues when timeout set by NormSetUserTimer() expires NORM_USER_TIMEOUT // issues when timeout set by NormSetUserTimer() expires
} NORM_API_LINKAGE NormEventType; } NORM_API_LINKAGE NormEventType;
@ -195,7 +195,7 @@ typedef struct
NormNodeHandle sender; NormNodeHandle sender;
NormObjectHandle object; NormObjectHandle object;
} NormEvent; } NormEvent;
// For setting custom NORM_OBJECT_DATA alloc/free functions // For setting custom NORM_OBJECT_DATA alloc/free functions
typedef char* (*NormAllocFunctionHandle)(size_t); typedef char* (*NormAllocFunctionHandle)(size_t);
@ -204,42 +204,39 @@ typedef void (*NormFreeFunctionHandle)(char*);
/** NORM API General Initialization and Operation Functions */ /** NORM API General Initialization and Operation Functions */
NORM_API_LINKAGE NORM_API_LINKAGE
int NormGetVersion(int* major DEFAULT((int*)0), int NormGetVersion(int* major DEFAULT((int*)0),
int* minor DEFAULT((int*)0), int* minor DEFAULT((int*)0),
int* patch DEFAULT((int*)0)); int* patch DEFAULT((int*)0));
NORM_API_LINKAGE
NORM_API_LINKAGE
NormInstanceHandle NormCreateInstance(bool priorityBoost DEFAULT(false)); NormInstanceHandle NormCreateInstance(bool priorityBoost DEFAULT(false));
NORM_API_LINKAGE NORM_API_LINKAGE
void NormDestroyInstance(NormInstanceHandle instanceHandle); void NormDestroyInstance(NormInstanceHandle instanceHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormStopInstance(NormInstanceHandle instanceHandle); void NormStopInstance(NormInstanceHandle instanceHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormRestartInstance(NormInstanceHandle instanceHandle); bool NormRestartInstance(NormInstanceHandle instanceHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormSuspendInstance(NormInstanceHandle instanceHandle); bool NormSuspendInstance(NormInstanceHandle instanceHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormResumeInstance(NormInstanceHandle instanceHandle); void NormResumeInstance(NormInstanceHandle instanceHandle);
// This MUST be set to enable NORM_OBJECT_FILE reception! // This MUST be set to enable NORM_OBJECT_FILE reception!
// (otherwise received files are ignored) // (otherwise received files are ignored)
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormSetCacheDirectory(NormInstanceHandle instanceHandle, bool NormSetCacheDirectory(NormInstanceHandle instanceHandle,
const char* cachePath); const char* cachePath);
// This call blocks until the next NormEvent is ready unless asynchronous // This call blocks until the next NormEvent is ready unless
// notification is used (see below) // "waitForEvent" is set to "false"
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormGetNextEvent(NormInstanceHandle instanceHandle, NormEvent* theEvent, bool waitForEvent DEFAULT(true)); bool NormGetNextEvent(NormInstanceHandle instanceHandle, NormEvent* theEvent, bool waitForEvent DEFAULT(true));
// The "NormGetDescriptor()" function returns a HANDLE (WIN32) or // The "NormGetDescriptor()" function returns a HANDLE (WIN32) or
@ -257,56 +254,56 @@ typedef int NormDescriptor;
#endif // if/else WIN32/UNIX #endif // if/else WIN32/UNIX
extern NORM_API_LINKAGE extern NORM_API_LINKAGE
const NormDescriptor NORM_DESCRIPTOR_INVALID; const NormDescriptor NORM_DESCRIPTOR_INVALID;
NORM_API_LINKAGE NORM_API_LINKAGE
NormDescriptor NormGetDescriptor(NormInstanceHandle instanceHandle); NormDescriptor NormGetDescriptor(NormInstanceHandle instanceHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetAllocationFunctions(NormInstanceHandle instance, void NormSetAllocationFunctions(NormInstanceHandle instance,
NormAllocFunctionHandle allocFunc, NormAllocFunctionHandle allocFunc,
NormFreeFunctionHandle freeFunc); NormFreeFunctionHandle freeFunc);
// NORM Session Creation and Control Functions // NORM Session Creation and Control Functions
NORM_API_LINKAGE NORM_API_LINKAGE
NormSessionHandle NormCreateSession(NormInstanceHandle instanceHandle, NormSessionHandle NormCreateSession(NormInstanceHandle instanceHandle,
const char* sessionAddress, const char* sessionAddress,
UINT16 sessionPort, UINT16 sessionPort,
NormNodeId localNodeId); NormNodeId localNodeId);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormDestroySession(NormSessionHandle sessionHandle); void NormDestroySession(NormSessionHandle sessionHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
NormInstanceHandle NormGetInstance(NormSessionHandle sessionHandle); NormInstanceHandle NormGetInstance(NormSessionHandle sessionHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormIsUnicastAddress(const char* address); bool NormIsUnicastAddress(const char* address);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetUserData(NormSessionHandle sessionHandle, const void* userData); void NormSetUserData(NormSessionHandle sessionHandle, const void* userData);
NORM_API_LINKAGE NORM_API_LINKAGE
const void* NormGetUserData(NormSessionHandle sessionHandle); const void* NormGetUserData(NormSessionHandle sessionHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetUserTimer(NormSessionHandle sessionHandle, double seconds); void NormSetUserTimer(NormSessionHandle sessionHandle, double seconds);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormCancelUserTimer(NormSessionHandle sessionHandle); void NormCancelUserTimer(NormSessionHandle sessionHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
NormNodeId NormGetLocalNodeId(NormSessionHandle sessionHandle); NormNodeId NormGetLocalNodeId(NormSessionHandle sessionHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormGetAddress(NormSessionHandle sessionHandle, bool NormGetAddress(NormSessionHandle sessionHandle,
char* addrBuffer, char* addrBuffer,
unsigned int* bufferLen, unsigned int* bufferLen,
UINT16* port DEFAULT((UINT16*)0)); UINT16* port DEFAULT((UINT16*)0));
NORM_API_LINKAGE NORM_API_LINKAGE
UINT16 NormGetRxPort(NormSessionHandle sessionHandle); UINT16 NormGetRxPort(NormSessionHandle sessionHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormSetTxPort(NormSessionHandle sessionHandle, bool NormSetTxPort(NormSessionHandle sessionHandle,
UINT16 txPortNumber, UINT16 txPortNumber,
bool enableReuse DEFAULT(false), bool enableReuse DEFAULT(false),
@ -326,8 +323,8 @@ void NormLimitObjectInfo(NormSessionHandle sessionHandle, bool state); // if tr
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormPresetObjectInfo(NormSessionHandle sessionHandle, // FEC OTI is preset and not sent bool NormPresetObjectInfo(NormSessionHandle sessionHandle, // FEC OTI is preset and not sent
unsigned long objectSize, // (most useful for NORM_OBJECT_STREAM) unsigned long objectSize, // (most useful for NORM_OBJECT_STREAM)
UINT16 segmentSize, UINT16 segmentSize,
UINT16 numData, UINT16 numData,
UINT16 numParity); UINT16 numParity);
NORM_API_LINKAGE NORM_API_LINKAGE
@ -348,7 +345,7 @@ NORM_API_LINKAGE
bool NormTransferSender(NormSessionHandle sessionHandle, NormNodeHandle sender); bool NormTransferSender(NormSessionHandle sessionHandle, NormNodeHandle sender);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetRxPortReuse(NormSessionHandle sessionHandle, void NormSetRxPortReuse(NormSessionHandle sessionHandle,
bool enableReuse, bool enableReuse,
const char* rxBindAddress DEFAULT((const char*)0), // if non-NULL, bind() to <rxBindAddress>/<sessionPort> const char* rxBindAddress DEFAULT((const char*)0), // if non-NULL, bind() to <rxBindAddress>/<sessionPort>
@ -368,27 +365,27 @@ void NormSetEcnSupport(NormSessionHandle sessionHandle,
bool ignoreLoss DEFAULT(false), // With "ecnEnable", use ECN-only, ignoring packet loss bool ignoreLoss DEFAULT(false), // With "ecnEnable", use ECN-only, ignoring packet loss
bool tolerateLoss DEFAULT(false)); // loss-tolerant congestion control, ecnEnable or not, ignoreLoss = false bool tolerateLoss DEFAULT(false)); // loss-tolerant congestion control, ecnEnable or not, ignoreLoss = false
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormSetMulticastInterface(NormSessionHandle sessionHandle, bool NormSetMulticastInterface(NormSessionHandle sessionHandle,
const char* interfaceName); const char* interfaceName);
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormSetSSM(NormSessionHandle sessionHandle, bool NormSetSSM(NormSessionHandle sessionHandle,
const char* sourceAddress); const char* sourceAddress);
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormSetTTL(NormSessionHandle sessionHandle, bool NormSetTTL(NormSessionHandle sessionHandle,
unsigned char ttl); unsigned char ttl);
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormSetTOS(NormSessionHandle sessionHandle, bool NormSetTOS(NormSessionHandle sessionHandle,
unsigned char tos); unsigned char tos);
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormSetLoopback(NormSessionHandle sessionHandle, bool NormSetLoopback(NormSessionHandle sessionHandle,
bool loopback); bool loopback);
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormSetMulticastLoopback(NormSessionHandle sessionHandle, bool NormSetMulticastLoopback(NormSessionHandle sessionHandle,
bool loopback); bool loopback);
@ -398,13 +395,13 @@ bool NormSetFragmentation(NormSessionHandle sessionHandle,
bool fragmentation); bool fragmentation);
// Special functions for debug support // Special functions for debug support
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetMessageTrace(NormSessionHandle sessionHandle, bool state); void NormSetMessageTrace(NormSessionHandle sessionHandle, bool state);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetTxLoss(NormSessionHandle sessionHandle, double percent); void NormSetTxLoss(NormSessionHandle sessionHandle, double percent);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetRxLoss(NormSessionHandle sessionHandle, double percent); void NormSetRxLoss(NormSessionHandle sessionHandle, double percent);
NORM_API_LINKAGE NORM_API_LINKAGE
@ -440,7 +437,7 @@ NormSessionId NormGetRandomSessionId();
// This function has been updated so that 16-bit Reed-Solomon // This function has been updated so that 16-bit Reed-Solomon
// codecs can be accessed. This may cause an issue for linking // codecs can be accessed. This may cause an issue for linking
// to older versions of the NORM library // to older versions of the NORM library
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormStartSender(NormSessionHandle sessionHandle, bool NormStartSender(NormSessionHandle sessionHandle,
NormSessionId instanceId, NormSessionId instanceId,
UINT32 bufferSpace, UINT32 bufferSpace,
@ -449,59 +446,59 @@ bool NormStartSender(NormSessionHandle sessionHandle,
UINT16 numParity, UINT16 numParity,
UINT8 fecId DEFAULT(0)); UINT8 fecId DEFAULT(0));
NORM_API_LINKAGE NORM_API_LINKAGE
void NormStopSender(NormSessionHandle sessionHandle); void NormStopSender(NormSessionHandle sessionHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetTxRate(NormSessionHandle sessionHandle, void NormSetTxRate(NormSessionHandle sessionHandle,
double bitsPerSecond); double bitsPerSecond);
NORM_API_LINKAGE NORM_API_LINKAGE
double NormGetTxRate(NormSessionHandle sessionHandle); double NormGetTxRate(NormSessionHandle sessionHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormSetTxSocketBuffer(NormSessionHandle sessionHandle, bool NormSetTxSocketBuffer(NormSessionHandle sessionHandle,
unsigned int bufferSize); unsigned int bufferSize);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetFlowControl(NormSessionHandle sessionHandle, void NormSetFlowControl(NormSessionHandle sessionHandle,
double flowControlFactor); double flowControlFactor);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetCongestionControl(NormSessionHandle sessionHandle, void NormSetCongestionControl(NormSessionHandle sessionHandle,
bool enable, bool enable,
bool adjustRate DEFAULT(true)); bool adjustRate DEFAULT(true));
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetTxRateBounds(NormSessionHandle sessionHandle, void NormSetTxRateBounds(NormSessionHandle sessionHandle,
double rateMin, double rateMin,
double rateMax); double rateMax);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetTxCacheBounds(NormSessionHandle sessionHandle, void NormSetTxCacheBounds(NormSessionHandle sessionHandle,
NormSize sizeMax, NormSize sizeMax,
UINT32 countMin, UINT32 countMin,
UINT32 countMax); UINT32 countMax);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetAutoParity(NormSessionHandle sessionHandle, void NormSetAutoParity(NormSessionHandle sessionHandle,
unsigned char autoParity); unsigned char autoParity);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetGrttEstimate(NormSessionHandle sessionHandle, void NormSetGrttEstimate(NormSessionHandle sessionHandle,
double grttEstimate); double grttEstimate);
NORM_API_LINKAGE NORM_API_LINKAGE
double NormGetGrttEstimate(NormSessionHandle sessionHandle); double NormGetGrttEstimate(NormSessionHandle sessionHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetGrttMax(NormSessionHandle sessionHandle, void NormSetGrttMax(NormSessionHandle sessionHandle,
double grttMax); double grttMax);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetGrttProbingMode(NormSessionHandle sessionHandle, void NormSetGrttProbingMode(NormSessionHandle sessionHandle,
NormProbingMode probingMode); NormProbingMode probingMode);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetGrttProbingInterval(NormSessionHandle sessionHandle, void NormSetGrttProbingInterval(NormSessionHandle sessionHandle,
double intervalMin, double intervalMin,
double intervalMax); double intervalMax);
@ -510,86 +507,86 @@ NORM_API_LINKAGE
void NormSetGrttProbingTOS(NormSessionHandle sessionHandle, void NormSetGrttProbingTOS(NormSessionHandle sessionHandle,
UINT8 probeTOS); UINT8 probeTOS);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetBackoffFactor(NormSessionHandle sessionHandle, void NormSetBackoffFactor(NormSessionHandle sessionHandle,
double backoffFactor); double backoffFactor);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetGroupSize(NormSessionHandle sessionHandle, void NormSetGroupSize(NormSessionHandle sessionHandle,
unsigned int groupSize); unsigned int groupSize);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetTxRobustFactor(NormSessionHandle sessionHandle, void NormSetTxRobustFactor(NormSessionHandle sessionHandle,
int robustFactor); int robustFactor);
NORM_API_LINKAGE NORM_API_LINKAGE
NormObjectHandle NormFileEnqueue(NormSessionHandle sessionHandle, NormObjectHandle NormFileEnqueue(NormSessionHandle sessionHandle,
const char* fileName, const char* fileName,
const char* infoPtr DEFAULT((const char*)0), const char* infoPtr DEFAULT((const char*)0),
unsigned int infoLen DEFAULT(0)); unsigned int infoLen DEFAULT(0));
NORM_API_LINKAGE NORM_API_LINKAGE
NormObjectHandle NormDataEnqueue(NormSessionHandle sessionHandle, NormObjectHandle NormDataEnqueue(NormSessionHandle sessionHandle,
const char* dataPtr, const char* dataPtr,
UINT32 dataLen, UINT32 dataLen,
const char* infoPtr DEFAULT((const char*)0), const char* infoPtr DEFAULT((const char*)0),
unsigned int infoLen DEFAULT(0)); unsigned int infoLen DEFAULT(0));
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormRequeueObject(NormSessionHandle sessionHandle, NormObjectHandle objectHandle); bool NormRequeueObject(NormSessionHandle sessionHandle, NormObjectHandle objectHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
NormObjectHandle NormStreamOpen(NormSessionHandle sessionHandle, NormObjectHandle NormStreamOpen(NormSessionHandle sessionHandle,
UINT32 bufferSize, UINT32 bufferSize,
const char* infoPtr DEFAULT((const char*)0), const char* infoPtr DEFAULT((const char*)0),
unsigned int infoLen DEFAULT(0)); unsigned int infoLen DEFAULT(0));
NORM_API_LINKAGE NORM_API_LINKAGE
void NormObjectSetUserData(NormObjectHandle objectHandle, const void* userData); void NormObjectSetUserData(NormObjectHandle objectHandle, const void* userData);
NORM_API_LINKAGE NORM_API_LINKAGE
const void* NormObjectGetUserData(NormObjectHandle objectHandle); const void* NormObjectGetUserData(NormObjectHandle objectHandle);
// TBD - we should add a "bool watermark" option to "graceful" stream closure??? // TBD - we should add a "bool watermark" option to "graceful" stream closure???
NORM_API_LINKAGE NORM_API_LINKAGE
void NormStreamClose(NormObjectHandle streamHandle, bool graceful DEFAULT(false)); void NormStreamClose(NormObjectHandle streamHandle, bool graceful DEFAULT(false));
NORM_API_LINKAGE NORM_API_LINKAGE
unsigned int NormGetStreamBufferSegmentCount(unsigned int bufferBytes, UINT16 segmentSize, UINT16 blockSize); unsigned int NormGetStreamBufferSegmentCount(unsigned int bufferBytes, UINT16 segmentSize, UINT16 blockSize);
NORM_API_LINKAGE NORM_API_LINKAGE
unsigned int NormStreamWrite(NormObjectHandle streamHandle, unsigned int NormStreamWrite(NormObjectHandle streamHandle,
const char* buffer, const char* buffer,
unsigned int numBytes); unsigned int numBytes);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormStreamFlush(NormObjectHandle streamHandle, void NormStreamFlush(NormObjectHandle streamHandle,
bool eom DEFAULT(false), bool eom DEFAULT(false),
NormFlushMode flushMode DEFAULT(NORM_FLUSH_PASSIVE)); NormFlushMode flushMode DEFAULT(NORM_FLUSH_PASSIVE));
NORM_API_LINKAGE NORM_API_LINKAGE
void NormStreamSetAutoFlush(NormObjectHandle streamHandle, void NormStreamSetAutoFlush(NormObjectHandle streamHandle,
NormFlushMode flushMode); NormFlushMode flushMode);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormStreamSetPushEnable(NormObjectHandle streamHandle, void NormStreamSetPushEnable(NormObjectHandle streamHandle,
bool pushEnable); bool pushEnable);
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormStreamHasVacancy(NormObjectHandle streamHandle); bool NormStreamHasVacancy(NormObjectHandle streamHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
unsigned int NormStreamGetVacancy(NormObjectHandle streamHandle, unsigned int bytesWanted = 0); unsigned int NormStreamGetVacancy(NormObjectHandle streamHandle, unsigned int bytesWanted = 0);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormStreamMarkEom(NormObjectHandle streamHandle); void NormStreamMarkEom(NormObjectHandle streamHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormSetWatermark(NormSessionHandle sessionHandle, bool NormSetWatermark(NormSessionHandle sessionHandle,
NormObjectHandle objectHandle, NormObjectHandle objectHandle,
bool overrideFlush DEFAULT(false)); bool overrideFlush DEFAULT(false));
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormSetWatermarkEx(NormSessionHandle sessionHandle, bool NormSetWatermarkEx(NormSessionHandle sessionHandle,
NormObjectHandle objectHandle, NormObjectHandle objectHandle,
const char* buffer, const char* buffer,
@ -597,17 +594,17 @@ bool NormSetWatermarkEx(NormSessionHandle sessionHandle,
bool overrideFlush DEFAULT(false)); bool overrideFlush DEFAULT(false));
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormResetWatermark(NormSessionHandle sessionHandle); bool NormResetWatermark(NormSessionHandle sessionHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormCancelWatermark(NormSessionHandle sessionHandle); void NormCancelWatermark(NormSessionHandle sessionHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormAddAckingNode(NormSessionHandle sessionHandle, bool NormAddAckingNode(NormSessionHandle sessionHandle,
NormNodeId nodeId); NormNodeId nodeId);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormRemoveAckingNode(NormSessionHandle sessionHandle, void NormRemoveAckingNode(NormSessionHandle sessionHandle,
NormNodeId nodeId); NormNodeId nodeId);
@ -619,11 +616,11 @@ NORM_API_LINKAGE
void NormSetAutoAckingNodes(NormSessionHandle sessionHandle, void NormSetAutoAckingNodes(NormSessionHandle sessionHandle,
NormTrackingStatus trackingStatus); NormTrackingStatus trackingStatus);
NORM_API_LINKAGE NORM_API_LINKAGE
NormAckingStatus NormGetAckingStatus(NormSessionHandle sessionHandle, NormAckingStatus NormGetAckingStatus(NormSessionHandle sessionHandle,
NormNodeId nodeId DEFAULT(NORM_NODE_ANY)); NormNodeId nodeId DEFAULT(NORM_NODE_ANY));
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormGetNextAckingNode(NormSessionHandle sessionHandle, bool NormGetNextAckingNode(NormSessionHandle sessionHandle,
NormNodeId* nodeId, NormNodeId* nodeId,
NormAckingStatus* ackingStatus DEFAULT(0)); NormAckingStatus* ackingStatus DEFAULT(0));
@ -634,77 +631,77 @@ bool NormGetAckEx(NormSessionHandle sessionHandle,
char* buffer, char* buffer,
unsigned int* buflen); unsigned int* buflen);
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormSendCommand(NormSessionHandle sessionHandle, bool NormSendCommand(NormSessionHandle sessionHandle,
const char* cmdBuffer, const char* cmdBuffer,
unsigned int cmdLength, unsigned int cmdLength,
bool robust DEFAULT(false)); bool robust DEFAULT(false));
NORM_API_LINKAGE NORM_API_LINKAGE
void NormCancelCommand(NormSessionHandle sessionHandle); void NormCancelCommand(NormSessionHandle sessionHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetSynStatus(NormSessionHandle sessionHandle, bool state); void NormSetSynStatus(NormSessionHandle sessionHandle, bool state);
/* NORM Receiver Functions */ /* NORM Receiver Functions */
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormStartReceiver(NormSessionHandle sessionHandle, bool NormStartReceiver(NormSessionHandle sessionHandle,
UINT32 bufferSpace); UINT32 bufferSpace);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormStopReceiver(NormSessionHandle sessionHandle); void NormStopReceiver(NormSessionHandle sessionHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetRxCacheLimit(NormSessionHandle sessionHandle, void NormSetRxCacheLimit(NormSessionHandle sessionHandle,
unsigned short countMax); unsigned short countMax);
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormSetRxSocketBuffer(NormSessionHandle sessionHandle, bool NormSetRxSocketBuffer(NormSessionHandle sessionHandle,
unsigned int bufferSize); unsigned int bufferSize);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetSilentReceiver(NormSessionHandle sessionHandle, void NormSetSilentReceiver(NormSessionHandle sessionHandle,
bool silent, bool silent,
int maxDelay DEFAULT(-1)); int maxDelay DEFAULT(-1));
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetDefaultUnicastNack(NormSessionHandle sessionHandle, void NormSetDefaultUnicastNack(NormSessionHandle sessionHandle,
bool unicastNacks); bool unicastNacks);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormNodeSetUnicastNack(NormNodeHandle remoteSender, void NormNodeSetUnicastNack(NormNodeHandle remoteSender,
bool unicastNacks); bool unicastNacks);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetDefaultSyncPolicy(NormSessionHandle sessionHandle, void NormSetDefaultSyncPolicy(NormSessionHandle sessionHandle,
NormSyncPolicy syncPolicy); NormSyncPolicy syncPolicy);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetDefaultNackingMode(NormSessionHandle sessionHandle, void NormSetDefaultNackingMode(NormSessionHandle sessionHandle,
NormNackingMode nackingMode); NormNackingMode nackingMode);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormNodeSetNackingMode(NormNodeHandle remoteSender, void NormNodeSetNackingMode(NormNodeHandle remoteSender,
NormNackingMode nackingMode); NormNackingMode nackingMode);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormObjectSetNackingMode(NormObjectHandle objectHandle, void NormObjectSetNackingMode(NormObjectHandle objectHandle,
NormNackingMode nackingMode); NormNackingMode nackingMode);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetDefaultRepairBoundary(NormSessionHandle sessionHandle, void NormSetDefaultRepairBoundary(NormSessionHandle sessionHandle,
NormRepairBoundary repairBoundary); NormRepairBoundary repairBoundary);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormNodeSetRepairBoundary(NormNodeHandle remoteSender, void NormNodeSetRepairBoundary(NormNodeHandle remoteSender,
NormRepairBoundary repairBoundary); NormRepairBoundary repairBoundary);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormSetDefaultRxRobustFactor(NormSessionHandle sessionHandle, void NormSetDefaultRxRobustFactor(NormSessionHandle sessionHandle,
int robustFactor); int robustFactor);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormNodeSetRxRobustFactor(NormNodeHandle remoteSender, void NormNodeSetRxRobustFactor(NormNodeHandle remoteSender,
int robustFactor); int robustFactor);
@ -716,90 +713,90 @@ bool NormPreallocateRemoteSender(NormSessionHandle sessionHandle,
UINT16 numParity, UINT16 numParity,
unsigned int streamBufferSize DEFAULT(0)); unsigned int streamBufferSize DEFAULT(0));
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormStreamRead(NormObjectHandle streamHandle, bool NormStreamRead(NormObjectHandle streamHandle,
char* buffer, char* buffer,
unsigned int* numBytes); unsigned int* numBytes);
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormStreamSeekMsgStart(NormObjectHandle streamHandle); bool NormStreamSeekMsgStart(NormObjectHandle streamHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
UINT32 NormStreamGetReadOffset(NormObjectHandle streamHandle); UINT32 NormStreamGetReadOffset(NormObjectHandle streamHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
UINT32 NormStreamGetBufferUsage(NormObjectHandle streamHandle); UINT32 NormStreamGetBufferUsage(NormObjectHandle streamHandle);
/** NORM Object Functions */ /** NORM Object Functions */
NORM_API_LINKAGE NORM_API_LINKAGE
NormObjectType NormObjectGetType(NormObjectHandle objectHandle); NormObjectType NormObjectGetType(NormObjectHandle objectHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormObjectHasInfo(NormObjectHandle objectHandle); bool NormObjectHasInfo(NormObjectHandle objectHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
UINT16 NormObjectGetInfoLength(NormObjectHandle objectHandle); UINT16 NormObjectGetInfoLength(NormObjectHandle objectHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
UINT16 NormObjectGetInfo(NormObjectHandle objectHandle, UINT16 NormObjectGetInfo(NormObjectHandle objectHandle,
char* buffer, char* buffer,
UINT16 bufferLen); UINT16 bufferLen);
NORM_API_LINKAGE NORM_API_LINKAGE
NormSize NormObjectGetSize(NormObjectHandle objectHandle); NormSize NormObjectGetSize(NormObjectHandle objectHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
NormSize NormObjectGetBytesPending(NormObjectHandle objectHandle); NormSize NormObjectGetBytesPending(NormObjectHandle objectHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormObjectCancel(NormObjectHandle objectHandle); void NormObjectCancel(NormObjectHandle objectHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormObjectRetain(NormObjectHandle objectHandle); void NormObjectRetain(NormObjectHandle objectHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormObjectRelease(NormObjectHandle objectHandle); void NormObjectRelease(NormObjectHandle objectHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormFileGetName(NormObjectHandle fileHandle, bool NormFileGetName(NormObjectHandle fileHandle,
char* nameBuffer, char* nameBuffer,
unsigned int bufferLen); unsigned int bufferLen);
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormFileRename(NormObjectHandle fileHandle, bool NormFileRename(NormObjectHandle fileHandle,
const char* fileName); const char* fileName);
NORM_API_LINKAGE NORM_API_LINKAGE
const char* NormDataAccessData(NormObjectHandle objectHandle); const char* NormDataAccessData(NormObjectHandle objectHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
char* NormDataDetachData(NormObjectHandle objectHandle); char* NormDataDetachData(NormObjectHandle objectHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
char* NormAlloc(size_t numBytes); char* NormAlloc(size_t numBytes);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormFree(char* dataPtr); void NormFree(char* dataPtr);
NORM_API_LINKAGE NORM_API_LINKAGE
NormNodeHandle NormObjectGetSender(NormObjectHandle objectHandle); NormNodeHandle NormObjectGetSender(NormObjectHandle objectHandle);
/** NORM Node Functions */ /** NORM Node Functions */
NORM_API_LINKAGE NORM_API_LINKAGE
NormNodeId NormNodeGetId(NormNodeHandle nodeHandle); NormNodeId NormNodeGetId(NormNodeHandle nodeHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormNodeGetAddress(NormNodeHandle nodeHandle, bool NormNodeGetAddress(NormNodeHandle nodeHandle,
char* addrBuffer, char* addrBuffer,
unsigned int* bufferLen, unsigned int* bufferLen,
UINT16* port DEFAULT((UINT16*)0)); UINT16* port DEFAULT((UINT16*)0));
NORM_API_LINKAGE NORM_API_LINKAGE
void NormNodeSetUserData(NormNodeHandle nodeHandle, const void* userData); void NormNodeSetUserData(NormNodeHandle nodeHandle, const void* userData);
NORM_API_LINKAGE NORM_API_LINKAGE
const void* NormNodeGetUserData(NormNodeHandle nodeHandle); const void* NormNodeGetUserData(NormNodeHandle nodeHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
@ -827,10 +824,10 @@ void NormNodeFreeBuffers(NormNodeHandle remoteSender);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormNodeDelete(NormNodeHandle remoteSender); void NormNodeDelete(NormNodeHandle remoteSender);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormNodeRetain(NormNodeHandle nodeHandle); void NormNodeRetain(NormNodeHandle nodeHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormNodeRelease(NormNodeHandle nodeHandle); void NormNodeRelease(NormNodeHandle nodeHandle);
/** Some experimental functions */ /** Some experimental functions */
@ -838,7 +835,7 @@ void NormNodeRelease(NormNodeHandle nodeHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
void NormReleasePreviousEvent(NormInstanceHandle instanceHandle); void NormReleasePreviousEvent(NormInstanceHandle instanceHandle);
NORM_API_LINKAGE NORM_API_LINKAGE
UINT32 NormCountCompletedObjects(NormSessionHandle sessionHandle); UINT32 NormCountCompletedObjects(NormSessionHandle sessionHandle);
@ -852,7 +849,7 @@ NORM_API_LINKAGE
bool NormNodeAllowSender(NormNodeId senderId); bool NormNodeAllowSender(NormNodeId senderId);
NORM_API_LINKAGE NORM_API_LINKAGE
bool NormNodeDenySender(NormNodeId senderId); bool NormNodeDenySender(NormNodeId senderId);
#ifdef __cplusplus #ifdef __cplusplus
} // end extern "C" } // end extern "C"

0
include/normEncoder.h Normal file → Executable file
View File

0
include/normEncoderMDP.h Normal file → Executable file
View File

0
include/normEncoderRS16.h Normal file → Executable file
View File

0
include/normEncoderRS8.h Normal file → Executable file
View File

0
include/normFile.h Normal file → Executable file
View File

0
include/normMessage.h Normal file → Executable file
View File

0
include/normNode.h Normal file → Executable file
View File

1
include/normObject.h Normal file → Executable file
View File

@ -30,6 +30,7 @@ class NormObject
enum CheckLevel enum CheckLevel
{ {
BLIND_CHECK,
TO_OBJECT, TO_OBJECT,
THRU_INFO, THRU_INFO,
TO_BLOCK, TO_BLOCK,

0
include/normPostProcess.h Normal file → Executable file
View File

0
include/normSegment.h Normal file → Executable file
View File

0
include/normSession.h Normal file → Executable file
View File

0
include/normSimAgent.h Normal file → Executable file
View File

0
include/normVersion.h Normal file → Executable file
View File

0
makefiles/Makefile.arm-linux Normal file → Executable file
View File

0
makefiles/Makefile.common Normal file → Executable file
View File

0
makefiles/Makefile.freebsd Normal file → Executable file
View File

0
makefiles/Makefile.hpux Normal file → Executable file
View File

0
makefiles/Makefile.iphone Normal file → Executable file
View File

0
makefiles/Makefile.linux Normal file → Executable file
View File

0
makefiles/Makefile.macosx Normal file → Executable file
View File

0
makefiles/Makefile.mklinux Normal file → Executable file
View File

0
makefiles/Makefile.netbsd Normal file → Executable file
View File

0
makefiles/Makefile.sgi Normal file → Executable file
View File

0
makefiles/Makefile.solaris Normal file → Executable file
View File

0
makefiles/Makefile.solx86 Normal file → Executable file
View File

0
makefiles/Makefile.x86_64-qnx Normal file → Executable file
View File

0
makefiles/android-ndk/AndroidManifest.xml Normal file → Executable file
View File

0
makefiles/android-ndk/README Normal file → Executable file
View File

0
makefiles/android-ndk/ant.properties Normal file → Executable file
View File

0
makefiles/android-ndk/build.xml Normal file → Executable file
View File

0
makefiles/android-ndk/jni/Android.mk Normal file → Executable file
View File

0
makefiles/android-ndk/jni/Application.mk Normal file → Executable file
View File

0
makefiles/android-ndk/proguard-project.txt Normal file → Executable file
View File

0
makefiles/android-ndk/project.properties Normal file → Executable file
View File

0
makefiles/java/Makefile.common Normal file → Executable file
View File

0
makefiles/java/Makefile.linux Normal file → Executable file
View File

0
makefiles/java/Makefile.macosx Normal file → Executable file
View File

0
makefiles/java/build.xml Normal file → Executable file
View File

0
makefiles/win32/Norm-2008.sln Normal file → Executable file
View File

0
makefiles/win32/Norm.sln Normal file → Executable file
View File

Some files were not shown because too many files have changed in this diff Show More