INtime SDK

https://support.tenasys.com/6-2
Admin
INtime SDK is a real-time operating system and development kit that provides tools and libraries for...
Tokens:923,396
Snippets:6,383
Trust Score:8.8
Update:10 months ago
Show doc for...
Tokens:
Raw
### Example: Setup Control Transfer

Source: https://support.tenasys.com/6-2/ovw_usb3

Example illustrating how to perform a control transfer using the `UsbControlXfer` function. It shows the required parameters such as request type, request code, value, index, and data buffer details.

```c
// set up a control transfer packet.
bRequestType = 0x40;
bRequest = 0x04;
wIndex = 0;
UsbControlXfer(udev, bRequestType, bRequest, 0, wIndex, NULL, 0, NULL, 0, to_ms);
```

--------------------------------

### Example: Setup Interrupt Transfer

Source: https://support.tenasys.com/6-2/ovw_usb3

Example demonstrating how to set up an asynchronous interrupt transfer using the `USB_MKRCVINTPIPE` macro and the `UsbInterruptXferAsync` function. It includes parameters for device, pipe, buffer, length, flags, interval, timeout, and callback function.

```c
// set up an interrupt transfer
pipe = USB_MKRCVINTPIPE(dev, endpoint.bEndpointAddress);
flags = 0;
to_ms = USB_DEFAULT_TIMEOUT;
UsbInterruptXferAsync(udev, pipe, buff, bufflen, flags, endpoint.bInterval, to_ms, async_mbx, cb_func);
```

--------------------------------

### Install Tether Server as Windows Service

Source: https://support.tenasys.com/6-2/Using_Installation

This command installs the tethering server as a Windows service, allowing the target system to maintain a tethered connection to the development system without manual intervention after initial setup. This is crucial for development purposes where the target relies on a licensed development system.

```shell
tetherserver -install

```

--------------------------------

### Create INtime Process using RtCreateProcess

Source: https://support.tenasys.com/6-2/iwin32_port

This snippet illustrates the core functionality of starting an INtime process from a Windows application. It uses the `RtCreateProcess` function, which mirrors the Win32 `CreateProcess` API but operates within the INtime environment. The example shows how to initiate the process and check for success.

```c
if (RtCreateProcess ("iwin32DemoR.rta", NULL,
    NULL, NULL, FALSE, 0, NULL, NULL, NULL, &pi)) {
  // get rid of our handles, this does NOT terminate the INtime process
  RtCloseHandle(pi.hThread);
  RtCloseHandle(pi.hProcess);
}
else
  return FALSE;
```

--------------------------------

### DHCP Client Configuration Example (dhclient.cfg)

Source: https://support.tenasys.com/6-2/dhclient_conf

This snippet shows a comprehensive example of a dhclient.cfg file, demonstrating various declarations for DHCP client configuration, including timeouts, rejection of specific servers, interface-specific settings, and alias declarations.

```dhclient.cfg
**       timeout 60;
           retry 60;
           reboot 10;
           select-timeout 5;
           initial-interval 2;
           reject 192.33.137.209;

           interface "ep0" {
               send host-name "andare.fugue.com";
               send dhcp-client-identifier 1:0:a0:24:ab:fb:9c;
               send dhcp-lease-time 3600;
               supersede domain-name "fugue.com rc.vix.com home.vix.com";
               prepend domain-name-servers 127.0.0.1;
               request subnet-mask, broadcast-address, time-offset, routers,
                       domain-name, domain-name-servers, host-name;
               require subnet-mask, domain-name-servers;
               script "/etc/dhclient-script";
               media "media 10baseT/UTP", "media 10base2/BNC";
           }

           alias {
             interface "ep0";
             fixed-address 192.5.5.213;
             option subnet-mask 255.255.255.255;
           }**
```

--------------------------------

### CIApp Constructor Example (C++)

Source: https://support.tenasys.com/6-2/ciapp

This C++ example demonstrates how to declare and instantiate an application object derived from CIApp. The constructor takes a string argument used to catalog the RT process object.

```cpp
CIMyAppp theApp("name");
```

--------------------------------

### ipfw Command Syntax Examples

Source: https://support.tenasys.com/6-2/util_ipfw

Provides examples of common ipfw command usages for managing firewall rules, including adding, listing, flushing, and deleting rules. It also covers enabling/disabling features and managing rule sets.

```shell
ipfw [-cq] add rule
ipfw [-acdefnNStT] [set N] {list | show} [rule | first-last ...]
ipfw [-f | -q] [set N] flush
ipfw [-q] [set N] {delete | zero | resetlog} [number ...]
ipfw enable
          {firewall | altq | one_pass | debug | verbose | dyn_keepalive}
ipfw disable
          {firewall | altq | one_pass | debug | verbose | dyn_keepalive}

ipfw set [disable number ...] [enable number ...]
ipfw set move [rule] number to number
ipfw set swap number number
ipfw set show

ipfw table number add addr[/masklen] [value]
ipfw table number delete addr[/masklen]
ipfw table number flush
ipfw table number list

ipfw {pipe | queue} number config config-options
ipfw [-s [field]] {pipe | queue} {delete | list | show} [number ...]

ipfw nat number config config-options

ipfw [-cfnNqS] [-p preproc [preproc-flags]] pathname
```

--------------------------------

### Example Usage of HPE_CONFIG_OPTIONS in C

Source: https://support.tenasys.com/6-2/st_hpe_config_options

Demonstrates how to initialize and use the HPE_CONFIG_OPTIONS structure with the hpeConfigOptions function. This example sets up multicast addresses and configures the device to receive them.

```c
unsigned char multaddr[][6] = {
{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}, // multicast address
{0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c} // another multicast address
};
HPE_CONFIG_OPTIONS conf = {
0, // option_flags, -- no option flags
sizeof(multaddr) / 6, // number of multicast addresses
multaddr // pointer to array of multicast addresses
};
status = hpeConfigOptions(h, &conf, sizeof(conf));
```

--------------------------------

### Example scanf Statements

Source: https://support.tenasys.com/6-2/scanf

Illustrates common usage patterns for the scanf function to read various data types from standard input. These examples demonstrate how to read strings, integers, long integers, and pointers into memory.

```c
scanf( "%s", &x ); // Read a string into memory
scanf( "%d", &x ); // Read an integer into memory
scanf( "%ld", &x ); // Read a long integer into memory
scanf( "%p", &x ); // Read a pointer into memory
```

--------------------------------

### Example: Output Word to Port (SDM 'o' Command)

Source: https://support.tenasys.com/6-2/o

This example demonstrates how to use the SDM 'o' command to output a value, calculated as AX + 1B9, as a word to port number 4. It highlights the 'w' flag for word transmission.

```text
**..ow 4, ax + 1b9**
```

--------------------------------

### C++ Exception Handling Example

Source: https://support.tenasys.com/6-2/ovw_exception

Illustrates standard C++ exception handling using try, catch, and throw. This example defines a custom exception class `MyException` and shows how to catch it. It also mentions the use of `_set_se_translator` to translate hardware faults into C++ exceptions for more detailed handling.

```cpp
class MyException : exception {
  /* members and functions as required */
};

try {
  /* perform some action that may result in a MyException exception */
}
catch (MyException e) {
  printf("MyException occurred\n");
  exit(1);
}

```

--------------------------------

### Example: Setting Process Attributes (C)

Source: https://support.tenasys.com/6-2/ST_NTXPROCATTRIBS

Demonstrates how to initialize and set the memory-related attributes for an INtime process using the PROCESSATTRIBUTES structure. This example shows how to configure minimum and maximum memory pools, virtual segment size, and object directory size, including using system defaults.

```c
PROCESSATTRIBUTES pa;

pa.PoolMin = 0;              // use system default
pa.PoolMax = 0;              // use system default
pa.VsegSize = 12*1024*1024;  // set vseg to 12 megabytes
pa.ObjdirSize = 0;           // use system default
```

--------------------------------

### Start INtime Kernel via Command Line

Source: https://support.tenasys.com/6-2/Using_Operation

This command initiates a specified INtime node (kernel). It's a direct method to start a real-time node from the command line interface. Ensure the 'nodemgr' command is accessible in your system's PATH.

```bash
nodemgr start NodeA
```

--------------------------------

### vc Command Usage and Output Examples

Source: https://support.tenasys.com/6-2/vc

Demonstrates how to use the 'vc' command with different scenarios, including valid INtime system calls, non-system calls, and non-CALL instructions. It shows the expected output for each case.

```text
**vc [pointer]**
```

```text
**gate #NNNN
(subsystem) system call**
```

```text
**1e0b:00401060  55                     push   ebp
1e0b:00401061  8bec                   mov    ebp, esp
1e0b:00401063  c705cc30400000000000   mov    dword ptr 04030cc, 0
1e0b:0040106d  c705c430400064000000   mov    dword ptr 04030c4, 064
1e0b:00401077  6820304000             push   0403020
1e0b:0040107c  e8ef020000             call   $+000002f4; a=00401370
1e0b:00401081  83c404                 add    esp, 04
1e0b:00401084  6a00                   push   0
1e0b:00401086  6800100000             push   01000
1e0b:0040108b  6830124000             push   0401230
1e0b:00401090  68c8000000             push   0c8
1e0b:0040109a  83c410                 add    esp, 010**
```

```text
..vc 1e0b:00401095
```

```text
**Not a system CALL**
```

```text
..vc 1e0b:00401095
```

```text
**gate #0158
(INtime) CreateRtThread**
```

```text
..vc 18A0:71
```

```text
**Not a system CALL**
```

```text
..vc 18A0:74
```

```text
**Not a CALL instruction**
```

--------------------------------

### Load INtime Application from Binary Resource (C++)

Source: https://support.tenasys.com/6-2/Using_Loading

Demonstrates how a Windows application can load an INtime real-time application (RTA file) by embedding it as a binary resource. This involves finding the resource, loading it into memory, creating a temporary file, writing the resource content to the temporary file, and then using ntxCreateRtProcess to load the real-time application from the temporary file. Error handling for resource loading and file operations is included.

```cpp
// find the RTA resource
if( ((hRsrc = FindResource(theApp.m_hInstance,  
MAKEINTRESOURCE(IDR_RTAPP),  
TEXT("RTAPP"))) == NULL) ||  
((dwRtaSize = SizeofResource(theApp.m_hInstance,hRsrc)) == 0)||  
(((hRta = LoadResource(theApp.m_hInstance,hRsrc)) == NULL)))
{
  tmp.LoadString(IDS_CANNOT_LOAD);
  MessageBox(tmp);
  return;
}
if ((lpRta = LockResource(hRta)) == NULL)
{
  tmp.LoadString(IDS_CANNOT_LOAD);
  MessageBox(tmp);
  return;
}

// Create the temporary file.
hRtaFile = CreateFile(_T(“RTApp.TMP”),  
GENERIC_READ | GENERIC_WRITE,  
0, // no share  
NULL, // security  
CREATE_ALWAYS,  
FILE_ATTRIBUTE_NORMAL,  
NULL);

If( hRtaFile == INVALID_HANDLE_VALUE)
{
  tmp.LoadString(IDS_CANNOT_LOAD);
  MessageBox(tmp);
  return;
}

// Write the resource into the file  
WriteFile(hRtaFile, lpRta, dwRtaSize, &dummy, NULL);
CloseHandle(hRtaFile);

hRemoteApp = ntxCreateRtProcess(hNtx,TEXT(“RTApp.TMP”),(LPTSTR)(LPCTSTR)args,  
&procAttribs, NTX_PROC_SHOW_PROGRESS );
```

--------------------------------

### HPE API Transmit Frame Example

Source: https://support.tenasys.com/6-2/ovw_hpe

Transmits a frame after the interface has been set up. This involves loading data, attaching the transmit buffer set, and starting the transmitter. It also includes waiting for the transmission to complete.

```c
// user function to initialize the frames to be transmitted
FillTransmitPayload(tx_buffers[0].fragments[1].ptr);

hpeAttachTransmitBufferSet(handle, tx_buffers);
status = hpeStartTransmitter(handle);

// wait for 1 second:
status = hpeWaitForTransmitComplete(handle, 1000);
```

--------------------------------

### Initialize USB Client and Register Callbacks

Source: https://support.tenasys.com/6-2/ovw_usb3

This C code snippet demonstrates the initialization sequence for a USB client. It synchronizes with the USB stack and registers attach and detach callback functions. Ensure usbif3.h is included and usbif.lib is linked.

```c
void main(void) {
  // Wait for the USB stack to become available.
  UsbSynchronize(USB_WAIT_FOREVER);
  UsbEventsWithCallback(kbd_attach, kbd_detach, USB_WAIT_FOREVER);
}
```

--------------------------------

### Get Kernel State using sysctl

Source: https://support.tenasys.com/6-2/util_sysctl

This command retrieves the current value of a kernel variable. It takes the variable name as an argument and outputs its value. For example, 'sysctl kern.maxproc' retrieves the maximum number of processes allowed in the system.

```bash
sysctl kern.maxproc
```

--------------------------------

### DST Date Format Example (Text)

Source: https://support.tenasys.com/6-2/tzset

Details the format for specifying Daylight Saving Time (DST) start and end dates within the TZ environment variable. It supports Julian dates, month-day-week formats, and day of the week.

```text
<julian0>|J<julian1>|M<month>.<week>.<day>
```

--------------------------------

### Create and Configure a Bridge Interface

Source: https://support.tenasys.com/6-2/if_bridge

This example demonstrates creating a bridge interface named 'bridge0', adding member interfaces 'ven0' and 'ie1g0' to it, and bringing the bridge interface up. This configuration can be used to implement an 802.11-to-Ethernet bridge.

```shell
ifconfig.rta -q bridge create

ifconfig.rta bridge0 addm ven0 addm ie1g0 up
```

--------------------------------

### Example: Creating a Listening Socket

Source: https://support.tenasys.com/6-2/getaddrinfo

Illustrates setting up a wildcard listening socket for the 'http' service across all available address families using getaddrinfo.

```APIDOC
## Example: Creating a Listening Socket

### Description
This example demonstrates how to create a wildcard listening socket on the `http` service, available on all address families. It uses `getaddrinfo()` with the `AI_PASSIVE` flag to obtain addresses suitable for binding, then proceeds to create, bind, and listen on sockets for each resolved address.

### Method
`getaddrinfo()` (C Library Function)
`socket()` (C Library Function)
`bind()` (C Library Function)
`listen()` (C Library Function)
`close()` (C Library Function)
`freeaddrinfo()` (C Library Function)

### Endpoint
N/A (C Library Functions)

### Parameters
See `getaddrinfo()` and related functions for parameter details. Note the use of `AI_PASSIVE` flag in `hints`.

### Request Example
```c
struct addrinfo hints, *res, *res0;
int error;
int s[MAXSOCK];
int nsock;
const char *cause = NULL;

memset(&hints, 0, sizeof(hints));
hints.ai_family = PF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_flags = AI_PASSIVE;

error = getaddrinfo(NULL, "http", &hints, &res0);
if (error) {
    errx(1, "%s", gai_strerror(error));
    /*NOTREACHED*/
}

nsock = 0;
for (res = res0; res && nsock < MAXSOCK; res = res->ai_next) {
    s[nsock] = socket(res->ai_family, res->ai_socktype,
        res->ai_protocol);
    if (s[nsock] < 0) {
            cause = "socket";
            continue;
    }

    if (bind(s[nsock], res->ai_addr, res->ai_addrlen) < 0) {
            cause = "bind";
            close(s[nsock]);
            continue;
    }
    (void) listen(s[nsock], 5);

    nsock++;
}
if (nsock == 0) {
    err(1, "%s", cause);
    /*NOTREACHED*/
}
freeaddrinfo(res0);
```

### Response
#### Success Response (Listening Sockets Created)
- An array `s` containing valid socket descriptors for listening sockets.
- `nsock` indicates the number of listening sockets successfully created.

#### Response Example
(Successful creation results in valid socket descriptors in the `s` array)

#### Error Response
- If socket creation, binding, or listening fails for all addresses, `err` will be called with an error message.
```

--------------------------------

### PCI Legacy Interrupt Handler Setup

Source: https://support.tenasys.com/6-2/ovw_pci

Sets up a legacy interrupt handler for a PCI device. It first retrieves the interrupt level using PciGetInterruptLevel, checks if the device generates interrupts, and then installs the handler using SetRtInterruptHandlerEx with the SHARED_LEVEL parameter. The returned value is a modified interrupt level.

```c
WORD wHwLevel;
WORD wLevel;

SetRtProcessMaxPriority(NULL_RTHANDLE, 0);
wHwLevel = PciGetInterruptLevel(&pci);
if (wHwLevel == 0xffff) {
  printf("Device does not generate legacy interrupts\n");
  return;
}

wHwLevel |= SHARED_LEVEL;
wLevel = SetRtInterruptHandlerEx(wHwLevel, 16, MyIntHandler, pParam);

```

--------------------------------

### Initialize Multicast Routing (C)

Source: https://support.tenasys.com/6-2/multicast

Demonstrates the use of getsockopt and setsockopt to initialize multicast routing for IPv4 and IPv6 using MRT_INIT and MRT6_INIT options. Requires sys/types.h, sys/socket.h, netinet/in.h, netinet/ip_mroute.h, and netinet6/ip6_mroute.h headers.

```c
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip_mroute.h>
#include <netinet6/ip6_mroute.h>

int
getsockopt(int s, IPPROTO_IP, MRT_INIT, void *optval, socklen_t *optlen);

int
setsockopt(int s, IPPROTO_IP, MRT_INIT, const void *optval,
  socklen_t optlen);

int
getsockopt(int s, IPPROTO_IPV6, MRT6_INIT, void *optval,
  socklen_t *optlen);

int
setsockopt(int s, IPPROTO_IPV6, MRT6_INIT, const void *optval,
  socklen_t optlen);
```

--------------------------------

### Measure Thread Execution Time using clock (C)

Source: https://support.tenasys.com/6-2/clock

The clock function measures the time used by the calling thread from its start to the current moment. It is defined in `time.h`. The return value needs to be divided by `CLOCKS_PER_SEC` to get the actual time in seconds. In real-time multitasking systems, this function may not accurately reflect processor time used.

```c
#include <time.h>

clock_t clock(void);
```

--------------------------------

### ntxStartLocalRtNode

Source: https://support.tenasys.com/6-2/ntxstartlocalrtnode

Tries to start the RT kernel on the specified Node. Successful completion means that the start has been initiated but does not necessarily mean that it completed successfully. Use ntxGetRtStatus to determine if the RT kernel started successfully.

```APIDOC
## ntxStartLocalRtNode

### Description
Tries to start the RT kernel on the specified Node. Successful completion means that the start has been initiated but does not necessarily mean that it completed successfully. Use ntxGetRtStatus to determine if the RT kernel started successfully.

### Method
---

### Endpoint
---

### Parameters
#### Path Parameters
---

#### Query Parameters
---

#### Request Body
---

### Request Example
---

### Response
#### Success Response (NTXSTATUS)
- `E_PARAM` (NTXSTATUS) - The location parameter is invalid.
- `E_LOCATION` (NTXSTATUS) - The specified location is not a local Node.
- `E_NTX_COMM_FAILURE` (NTXSTATUS) - The DLL could not contact the INtime Kernel Service to complete the request.

#### Response Example
```c
NTXSTATUS status = ntxStartLocalRtNode(hLoc);
```
```

--------------------------------

### syslog Usage Examples (C)

Source: https://support.tenasys.com/6-2/syslog

Illustrates common use cases for syslog functions, including logging specific priorities, setting logging options with openlog, and configuring log masks with setlogmask.

```c
syslog(LOG_ALERT, "who: internal error 23");
openlog("ftpd", LOG_PID | LOG_NDELAY, LOG_FTP);
setlogmask(LOG_UPTO(LOG_ERR));
syslog(LOG_INFO, "Connection from host %d", CallingHost);
syslog(LOG_INFO|LOG_LOCAL2, "foobar error: %m");
```

--------------------------------

### Loader Synchronization Options

Source: https://support.tenasys.com/6-2/Using_Loading

Explains options for the load client to wait for an application to complete initialization before proceeding with the next application in a sequence. This prevents issues where a dependent application starts before its prerequisite is ready.

```text
ldrta.exe: use -W to wait for default timeout (20s).
ldrta.exe: use -WAIT _nnnn_ for custom timeout in milliseconds.
CreateRtProcess: use PROC_WAIT_FOR_INIT flag for default 30s wait.
CreateRtProcessEx: use PROC_WAIT_FOR_INIT_PARAM and set WaitForInit field for custom timeout.
```

--------------------------------

### Start Local RT Node (Visual Basic)

Source: https://support.tenasys.com/6-2/ntxstartlocalrtnode2

Initiates the start of the RT kernel on a specified local node using Visual Basic. Successful completion indicates the start has been initiated, not necessarily finished. Use ntxGetRtStatus to verify.

```vb
Sub ntxStartLocalRtNode(
        ByVal hLoc As Integer)

```

--------------------------------

### HPE API Initialization Example

Source: https://support.tenasys.com/6-2/ovw_hpe

Initializes the network interface by opening it, attaching receive buffers, and attaching transmit buffers. This involves allocating and configuring buffer sets for both transmission and reception.

```c
HPESTATUS status;
HPEHANDLE handle;
HPERXBUFFERSET *rx_buffers;
HPETXBUFFERSET *tx_buffers;
int i;
char *p;
static char fixed_header[56];   // 56-byte fixed header for each transmitted frame


status = hpeOpen("ie1g0", SPEED_100|DUPLEX_FULL, ALL_INTERRUPTS, &handle);
// allocate 4 receive buffers and attach them
status  = hpeAllocateReceiveBufferSet(handle, &rx_buffers, 4, ETH_FRAME_SIZE);
status = hpeAttachReceiveBufferSet(handle, rx_buffers);
// allocate 1 transmit buffer of two fragments and 500 bytes and attach it
tx_buffers = AllocateRtMemory(4096);
p = (char *)&tx_buffers->buffers[1];
tx_buffers->buffer_count = 1;
tx_buffers->buffers[0].fragment_count = 2;
// first fragment is the fixed header, second is dynamic data
tx_buffers->buffers[0].fragments[0].ptr = fixed_header;
tx_buffers->buffers[0].fragments[0].size = 56;
tx_buffers->buffers[0].fragments[0].paddr = 0;
tx_buffers->buffers[0].fragments[1].ptr = p;
tx_buffers->buffers[0].fragments[1].size = 444;
tx_buffers->buffers[0].fragments[1].paddr = 0;

status = hpeAttachTransmitBufferSet(handle, tx_buffers);
```

--------------------------------

### gets function for C

Source: https://support.tenasys.com/6-2/gets

The gets function reads characters from standard input until a newline character is encountered or end-of-file is reached. It stores the characters in the provided buffer and replaces the newline with a null terminator. Returns the buffer on success, or a null pointer on error.

```c
#include <stdio.h>

char *gets (char *buffer);

```

--------------------------------

### gethostbyaddr Example

Source: https://support.tenasys.com/6-2/gethostbyname

This example demonstrates how to use the gethostbyaddr function to find the hostname associated with a given IP address.

```APIDOC
## GET /gethostbyaddr

### Description
Retrieves the hostname associated with a given IP address.

### Method
GET

### Endpoint
N/A (Function call example)

### Parameters
None

### Request Example
```c
const char *ipstr = "127.0.0.1";
struct in_addr ip;
struct hostent *hp;

if (!inet_aton(ipstr, &ip))
        errx(1, "can\'t parse IP address %s", ipstr);

if ((hp = gethostbyaddr((const void *)&ip,
    sizeof ip, AF_INET)) == NULL)
        errx(1, "no name associated with %s", ipstr);

printf("name associated with %s is %s\n", ipstr, hp->h_name);
```

### Response
#### Success Response (200)
- **hp->h_name** (string) - The hostname associated with the IP address.

#### Response Example
```json
{
  "hostname": "your_hostname"
}
```
```

--------------------------------

### lncAssignMemory Function

Source: https://support.tenasys.com/6-2/lnc_assignmemory

Assigns start addresses to all local nodes and determines total size and start address (if using excluded memory).

```APIDOC
## lncAssignMemory

### Description
Assigns start addresses to all local nodes and determines total size and start address (if using excluded memory).

### Method
`DWORD lncAssignMemory();`

### Endpoint
N/A (SDK Function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```c
DWORD result = lncAssignMemory();
```

### Response
#### Success Response (0)
Returns `0` for success.

#### Error Response
Returns an error code on failure, such as `LNCE_MEMTOOMUCH`.

#### Response Example
```c
// Success
DWORD result = 0;

// Failure example
// DWORD result = LNCE_MEMTOOMUCH;
```

### Requirements
- Versions: INtime 5.2
- Defined in: intime/nt/include/lnc.h
- Include: lnc.h
- Link to: lnc.lib

### See Also
- LNC: Local Node Configuration library
```

--------------------------------

### Create and Manage INtime Process with C

Source: https://support.tenasys.com/6-2/iwin32_port

Demonstrates how to create an INtime process using `RtCreateProcess` and manage its handles. This function is analogous to the Win32 `CreateProcess` function but specifically for INtime processes. It also shows how to properly close handles using `RtCloseHandle` without terminating the INtime process.

```c
#include <afx.h>
#include <iwin32x.h>
#include "measureW.h"
////////////////////////////////////////////////////////
// The global data
typedef struct {
  DWORD min, max;
  BOOLEAN bRun;
} VALUES, * PVALUES;
static PVALUES pVal;
////////////////////////////////////////////////////////
BOOLEAN InitMeasure(void)
{
  HANDLE hMem;
  PROCESS_INFORMATION pi;
  if (CreateProcess ("iwin32DemoR.rta", NULL,
        NULL, NULL, FALSE, 0, NULL, NULL,
        NULL, &pi)) {
    // get rid of our handles, this does NOT terminate the INtime process
    RtCloseHandle(pi.hThread);
    RtCloseHandle(pi.hProcess);
  }
  else
    return FALSE;
  hMem = RtOpenSharedMemory(0, 0, "iwin32DemoMem", (VOID**)&pVal);
  if (hMem == NULL)
    return FALSE;
  return TRUE;
}
////////////////////////////////////////////////////////
void GetMeasure(
  int * pMin,
  int * pMax)
{
  *pMin = pVal->min;
  *pMax = pVal->max;
}
////////////////////////////////////////////////////////
void ClearMeasure(void)
{
  pVal->min = 10000000;
  pVal->max = 0;
}
////////////////////////////////////////////////////////
void StopMeasure(void)
{
  pVal->bRun = FALSE;
}
```

--------------------------------

### GetRtSystemMemoryInfo Function Signature and C Example

Source: https://support.tenasys.com/6-2/getrtsystemmemoryinfo

This snippet shows the declaration of the GetRtSystemMemoryInfo function and a complete C example demonstrating its usage. The example retrieves and prints information about system memory areas, including their base address, size, and flags. It handles cases where multiple memory areas exist and includes error checking.

```c
BOOLEAN GetRtSystemMemoryInfo(
    DWORD dwMemtype, 
    LPVOID pMemoryInfo
);
```

```c
#include <stdio.h>
#include <rt.h>

int main(int argc, char* argv[])
{
    SYSTEM_MEMORY_INFO smi, *smip;
    DWORD i, n;

    // Start with a buffer for a single area
    // Initialize the count to 1
    smi.count = 1;
    if (GetRtSystemMemoryInfo(GET_SYSTEM_MEMORY_AREA_LIST, &smi)) {
        // the call returns the number of areas available
        n = smi.count;
        if (n > 1) {
            // now get the data for all of the areas
            smip = malloc(4+(sizeof(smi.area)*n));
            smip->count = n;
            if (!GetRtSystemMemoryInfo(GET_SYSTEM_MEMORY_AREA_LIST, smip)) {
                printf("Failed to GetRtSystemMemoryInfo: %04x\n", GetLastRtError());
                return 1;
            }
        }
        else {
            smip = &smi;
        }
        for (i = 0; i < smip->count; i++) {
            printf("Pool %u: base %05x_%08x size %llu MB flags=%u\n",
                i, (DWORD)(smip->area[i].area_base>>32), (DWORD)(smip->area[i].area_base), smip->area[i].area_size/0x100000, smip->area[i].area_flags);
        }
    }
    else {
        printf("Could not GetRtSystemMemoryInfo: %04x\n", GetLastRtError());
    }

    return 0;
}
```

--------------------------------

### Install Custom Debug Memory Dump Function (_CrtSetDumpClient C)

Source: https://support.tenasys.com/6-2/_crtsetdumpclient

Installs a custom application-defined function to handle the dumping of _CLIENT_BLOCK type memory blocks during C runtime debug memory operations. This function is part of the debug heap management and is removed when _DEBUG is not defined. It returns the previously installed dump function.

```c
#define _CRT_DUMP_CLIENT _CRT_DUMP_CLIENT

_CRT_DUMP_CLIENT _CrtSetDumpClient (
    _CRT_DUMP_CLIENT pfnNewDump
);
```

--------------------------------

### Setting Up MSI Interrupt Handlers

Source: https://support.tenasys.com/6-2/ovw_interrupt

This section describes how to install interrupt handlers for each MSI vector using `SetRtInterruptHandlerEx`.

```APIDOC
## Set Up Multiple MSI Interrupt Handlers

### Description
This endpoint allows you to install specific interrupt handlers for each available MSI vector of a device.

### Method
- `SetRtInterruptHandlerEx` (Function Call)

### Endpoint
N/A (This is a function call within the INtime kernel SDK)

### Parameters
#### Function: `SetRtInterruptHandlerEx`
- **MSI_PARAM_EX** (*structure*) - Input - Structure containing parameters for the extended interrupt handler setup.
  - **PciAddress** (*PCIADDRESS*) - The PCI address of the device.
  - **MsiIndex** (*unsigned integer*) - The index of the MSI vector to program (0-based).
  - **MsiVectors** (*RT_INTERRUPT_VECTOR* array*) - Pointer to the allocated interrupt vectors.
  - **ReservedZero** (*unsigned integer*) - Must be set to 0.
  - **Param** (*pointer*) - User-defined parameter passed to the interrupt handler.
- **MSI_LEVEL** (*constant*) - Specifies the interrupt level type.
- **1** (*unsigned integer*) - Indicates a single handler is being set.
- **MsiHandler** (*function pointer*) - Pointer to the interrupt handler function.
- **&msi** (*pointer to MSI_PARAM_EX*) - Pointer to the `MSI_PARAM_EX` structure.

### Request Example
```c
// Assuming 'pci' is a valid PCI_INFO structure and 'nVectors' is the number of MSI vectors
ULONG nVectors = PciGetMsiCount(&pci);
RT_INTERRUPT_VECTOR* interruptVectors = AllocateRtInterrupts(nVectors);

if (interruptVectors != NULL) {
    for (int i = 0; i < nVectors; ++i) {
        MSI_PARAM_EX msi;
        msi.PciAddress = MKPCIADDR(&pci);
        msi.MsiIndex = i;
        msi.MsiVectors = interruptVectors;
        msi.ReservedZero = 0;
        // 'Param' should be set to user-specific data if needed
        msi.Param = NULL; 

        int wLevel = SetRtInterruptHandlerEx(MSI_LEVEL, 1, MsiHandler, &msi);
        // Check wLevel for errors
    }
}
```

### Response
#### Success Response (Return value of `SetRtInterruptHandlerEx`)
- Returns a value indicating the interrupt level or status. Specific success codes depend on the INtime SDK implementation.

#### Response Example
```json
{
  "handler_setup_status": "SUCCESS", // Example status indicator
  "interrupt_level": 5 // Example return value
}
```
```

--------------------------------

### HPE API Receive Frame Example

Source: https://support.tenasys.com/6-2/ovw_hpe

Receives frames by first checking for available buffers, processing the data, and then reusing the buffer. This example uses hpeWaitForReceiveComplete to wait for a frame and hpeGetReceiveBuffer to retrieve it.

```c
// user function to initialize the frames to be transmitted
HPEBUFFER *rxbuffer;

hpeWaitForReceiveComplete(handle, 1000);
if (hpeGetReceiveBuffer(handle, &rxbuffer) == E_OK)
    process_buffer_data(rxbuffer->ptr, rxbuffer->used);       // user function
```

--------------------------------

### Displaying Software Breakpoints

Source: https://support.tenasys.com/6-2/bs

This example shows the format for displaying software breakpoints when using the 'bs' command without parameters. It indicates the reason code, breakpoint type (software), and address.

```plaintext
**00001000 s 00020af0**
```

--------------------------------

### Start Local RT Node (C#)

Source: https://support.tenasys.com/6-2/ntxstartlocalrtnode2

Initiates the start of the RT kernel on a specified local node using C#. The function call itself does not guarantee successful completion; ntxGetRtStatus should be used for verification.

```csharp
void ntxStartLocalRtNode(
        int32 hLoc)

```

--------------------------------

### Displaying Hardware Breakpoints (Data/IO with Length)

Source: https://support.tenasys.com/6-2/bs

This example shows the format for displaying hardware breakpoints that involve data access (modify, write) or I/O access, along with a specified length parameter (byte, halfword, or word). It includes the reason code, breakpoint type, address, access type, and length.

```plaintext
**00000201 h 000d1240 m h**
```

--------------------------------

### Packet Dump File Operations

Source: https://support.tenasys.com/6-2/pcap

Functions for managing packet dump files, including getting the file stream, flushing buffers, getting file position, and closing the file.

```APIDOC
## Packet Dump File Functions

### Description
This group of functions manages the 'savefile' used for dumping captured packets. `pcap_dump_file` returns the associated I/O stream, `pcap_dump_flush` ensures buffered data is written, `pcap_dump_ftell` gets the current file position, and `pcap_dump_close` closes the file.

### Method
GET/POST/PUT/DELETE (depending on the specific function's operation)

### Endpoint
N/A (Library functions)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```c
FILE *fp = pcap_dump_file(dumper);
int flushed = pcap_dump_flush(dumper);
long pos = pcap_dump_ftell(dumper);
pcap_dump_close(dumper);
```

### Response
#### Success Response (200)
- **pcap_dump_file**: Returns a FILE pointer.
- **pcap_dump_flush**: Returns 0 on success, -1 on error.
- **pcap_dump_ftell**: Returns the current file position, -1 on error.
- **pcap_dump_close**: Returns void (no specific success/failure return value mentioned for close itself, relies on other functions for error checking).

#### Response Example
```json
{
  "file_pointer_address": "0x...",
  "flush_status": 0,
  "file_position": 12345
}
```
(Conceptual representation of potential return values.
```

--------------------------------

### Example: Connecting to a Host

Source: https://support.tenasys.com/6-2/getaddrinfo

Demonstrates how to use getaddrinfo to resolve a hostname and port, then iterate through the resulting addresses to establish a socket connection.

```APIDOC
## Example: Connecting to a Host

### Description
This example illustrates connecting to `www.kame.net` on the `http` service using a stream socket. It iterates through all available addresses returned by `getaddrinfo()`, attempting to create a socket and connect for each. The code dynamically handles both IPv4 and IPv6 addresses without hardcoding specific families.

### Method
`getaddrinfo()` (C Library Function)
`socket()` (C Library Function)
`connect()` (C Library Function)
`close()` (C Library Function)
`freeaddrinfo()` (C Library Function)

### Endpoint
N/A (C Library Functions)

### Parameters
See `getaddrinfo()` and related functions for parameter details.

### Request Example
```c
struct addrinfo hints, *res, *res0;
int error;
int s;
const char *cause = NULL;

memset(&hints, 0, sizeof(hints));
hints.ai_family = PF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;

error = getaddrinfo("www.kame.net", "http", &hints, &res0);
if (error) {
    errx(1, "%s", gai_strerror(error));
    /*NOTREACHED*/
}

s = -1;
for (res = res0; res; res = res->ai_next) {
    s = socket(res->ai_family, res->ai_socktype,
        res->ai_protocol);
    if (s < 0) {
            cause = "socket";
            continue;
    }

    if (connect(s, res->ai_addr, res->ai_addrlen) < 0) {
            cause = "connect";
            close(s);
            s = -1;
            continue;
    }

    break;  /* okay we got one */
}
if (s < 0) {
    err(1, "%s", cause);
    /*NOTREACHED*/
}
freeaddrinfo(res0);
```

### Response
#### Success Response (Connection Established)
- The socket descriptor `s` will be valid and connected.

#### Response Example
(Successful connection results in a valid socket descriptor `s`)

#### Error Response
- If connection fails, `errx` or `err` will be called with an error message.
```

--------------------------------

### Create and Open File for Writing (C)

Source: https://support.tenasys.com/6-2/creat

The `creat` function creates a new file or truncates an existing one to zero length, preparing it for writing. It takes a filename and permission mode as input. Permissions are affected by the umask. By default, files are sharable; use O_EXCL for exclusive access.

```c
#include <sys/types.h>
#include <sys/stat.h>
#include <io.h>

int creat (const char *filename, mode_t pmode);
```

--------------------------------

### Start a Suspended Real-Time Process (Visual Basic, C#)

Source: https://support.tenasys.com/6-2/ntxstartrtprocess2

Starts a real-time process that was previously loaded using ntxCreateRtProcess with the NTX_PROC_SUSPEND flag. The function returns a handle for synchronization and retrieving the exit code.

```Visual Basic
**Function StartRtProcess(
    ByVal hProcess As Integer,
    ByRef phExit As Integer **)
```

```C#
**void StartRtProcess(
    Int32 hProcess,
    ref Int32 phExit );**
```

--------------------------------

### Create Wildcard Listening Sockets with getaddrinfo (C)

Source: https://support.tenasys.com/6-2/getaddrinfo

This C code example shows how to use getaddrinfo() to create wildcard listening sockets for a given service across all available address families. It initializes hints for passive socket creation, resolves the service name to a list of addresses, and then attempts to create a socket, bind it, and start listening for each resolved address. It handles potential errors during socket creation and binding. The function freeaddrinfo() is used to release allocated memory. Dependencies include standard C libraries and POSIX socket functions.

```c
struct addrinfo hints, *res, *res0;
int error;
int s[MAXSOCK];
int nsock;
const char *cause = NULL;

memset(&hints, 0, sizeof(hints));
hints.ai_family = PF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE;
error = getaddrinfo(NULL, "http", &hints, &res0);
if (error) {
        errx(1, "%s", gai_strerror(error));
        /*NOTREACHED*/
}
nsock = 0;
for (res = res0; res && nsock < MAXSOCK; res = res->ai_next) {
        s[nsock] = socket(res->ai_family, res->ai_socktype,
            res->ai_protocol);
        if (s[nsock] < 0) {
                cause = "socket";
                continue;
        }

        if (bind(s[nsock], res->ai_addr, res->ai_addrlen) < 0) {
                cause = "bind";
                close(s[nsock]);
                continue;
        }
        (void) listen(s[nsock], 5);

        nsock++;
}
if (nsock == 0) {
        err(1, "%s", cause);
        /*NOTREACHED*/
}
freeaddrinfo(res0);
```

--------------------------------

### Start a Suspended Process with StartRtProcess

Source: https://support.tenasys.com/6-2/startrtprocess

This C code snippet demonstrates how to use the StartRtProcess function to start a process that was created with the PROC_SUSPEND flag. The function requires a handle to the process and returns a wait handle for synchronization.

```c
#include <rt.h>

RTHANDLE hProcess;
// Assume hProcess is a valid handle to a process created with PROC_SUSPEND
RTHANDLE waitHandle = StartRtProcess(hProcess);

if (waitHandle == BAD_RTHANDLE) {
    // Handle error, check GetLastRtError()
    int error = GetLastRtError();
    // Handle E_STATE or E_CONTEXT errors as appropriate
} else {
    // Process started successfully, use waitHandle with WaitForRtProcessEx
}
```
Tokens:
Raw