liblolowlevel(3)

📦
version 0.34 · 3 versions
, in fedora 44

✨ NAME ✨

okay so bestie, meet liblolowlevel(3) from the Library Functions Manual 💖 — it's the Low-level OSC API. That's the whole name situation, and yes, it's giving foundational C library energy.

🦋 SYNOPSIS 🦋

📦 Data Structures 📦

  • struct lo_server_config — a configuration struct for initializing lo_server using lo_server_new_from_config(). Think of it as the setup sheet before the main character server makes its entrance ✨.

🏷️ Typedefs 🏷️

  • typedef long double lo_hires — type used to represent numerical values in conversions between OSC types. It's the numeric bestie for OSC type conversions, periodt 💅.

🌈 Enumerations 🌈

  • enum lo_slip_encoding — used with lo_address_set_stream_slip() to specify whether sent messages should be encoded with SLIP, and whether the encoding should be single- or double-ENDed. So it's the switch that decides SLIP encoding vibes and ENDing style 🦋.

Functions 💖✨

okay so this is the actual menu of everything you can call, bestie. Every single one, no skips. Go get your snack, this is a long one. 🍓

  • int lo_send_message (lo_address targ, const char *path, lo_message msg) — yeets a lo_message object over to target targ. 🚀
  • int lo_send_message_from (lo_address targ, lo_server serv, const char *path, lo_message msg) — same energy, but the message goes to targ from the address of serv. it's giving "who's your sender" 💅
  • int lo_send_bundle (lo_address targ, lo_bundle b) — sends a lo_bundle object to address targ. bundle goes brrr 🎀
  • int lo_send_bundle_from (lo_address targ, lo_server serv, lo_bundle b) — sends a lo_bundle object to address targ, except it's coming from the address of serv. 😌
  • lo_message lo_message_new (void) — creates a brand new lo_message object. newborn icon 👶✨
  • void lo_message_incref (lo_message m) — adds one to a message's reference count. +1 bestie 💖
  • int lo_message_decref (lo_message m) — subtracts one from a message's reference count. bye girl 👋
  • lo_message lo_message_clone (lo_message m) — creates a new lo_message object by cloning one that already exists. literally its twin 🪞
  • void lo_message_free (lo_message m) — frees the memory allocated by lo_message_new() and any subsequent lo_message_add_int32 lo_message_add*() calls. clean up after yourself fr fr 🧹
  • void lo_message_clear (lo_message m) — clears the elements out of a lo_message but does not free the allocated memory. emptied, not evicted 🫶
  • int lo_message_add (lo_message m, const char *types,...) — appends a number of arguments to a message. pile 'em on 🔥
  • int lo_message_add_varargs (lo_message m, const char *types, va_list ap) — appends a varargs list to a message. the varargs girlies ate 💅
  • int lo_message_add_int32 (lo_message m, int32_t a) — appends a data item and typechar of the specified type to a message. this one's the blueprint, everyone else points here 👑
  • int lo_message_add_float (lo_message m, float a) — appends a data item and typechar of the specified type to a message. see lo_message_add_int32() for details.
  • int lo_message_add_string (lo_message m, const char *a) — appends a data item and typechar of the specified type to a message. see lo_message_add_int32() for details.
  • int lo_message_add_blob (lo_message m, lo_blob a) — appends a data item and typechar of the specified type to a message. see lo_message_add_int32() for details.
  • int lo_message_add_int64 (lo_message m, int64_t a) — appends a data item and typechar of the specified type to a message. see lo_message_add_int32() for details.
  • int lo_message_add_timetag (lo_message m, lo_timetag a) — appends a data item and typechar of the specified type to a message. see lo_message_add_int32() for details.
  • int lo_message_add_double (lo_message m, double a) — appends a data item and typechar of the specified type to a message. see lo_message_add_int32() for details.
  • int lo_message_add_symbol (lo_message m, const char *a) — appends a data item and typechar of the specified type to a message. see lo_message_add_int32() for details.
  • int lo_message_add_char (lo_message m, char a) — appends a data item and typechar of the specified type to a message. see lo_message_add_int32() for details.
  • int lo_message_add_midi (lo_message m, uint8_t a[4]) — appends a data item and typechar of the specified type to a message. see lo_message_add_int32() for details.
  • int lo_message_add_true (lo_message m) — appends a data item and typechar of the specified type to a message. see lo_message_add_int32() for details.
  • int lo_message_add_false (lo_message m) — appends a data item and typechar of the specified type to a message. see lo_message_add_int32() for details.
  • int lo_message_add_nil (lo_message m) — appends a data item and typechar of the specified type to a message. see lo_message_add_int32() for details.
  • int lo_message_add_infinitum (lo_message m) — appends a data item and typechar of the specified type to a message. see lo_message_add_int32() for details. infinite, literally ∞ 😭
  • lo_address lo_message_get_source (lo_message m) — returns the source (lo_address) of an incoming message. who sent this?? 📬
  • lo_timetag lo_message_get_timestamp (lo_message m) — returns the timestamp (lo_timetag *) of a bundled incoming message. when did this happen ⏰
  • char * lo_message_get_types (lo_message m) — return the message type tag string. the receipts 🧾
  • int lo_message_get_argc (lo_message m) — return the message argument count. how many arguments, bestie 🔢
  • lo_arg ** lo_message_get_argv (lo_message m) — return the message arguments. do not free the returned data. > hands off, it's not yours to free 🙈
  • size_t lo_message_length (lo_message m, const char *path) — return the length of a message in bytes. measuring tape out 📏
  • void * lo_message_serialise (lo_message m, const char *path, void *to, size_t *size) — serialises the lo_message object to an area of memory and returns a pointer to the serialised form. it's the opposite of lo_message_deserialise(). glowed up into raw bytes ✨
  • lo_message lo_message_deserialise (void *data, size_t size, int *result) — deserialises a raw OSC message and returns a new lo_message object. opposite of lo_message_serialise(). raw bytes, but make it a message 💫
  • int lo_server_dispatch_data (lo_server s, void *data, size_t size) — dispatch a raw block of memory containing an OSC message. send it where it needs to go 🏃‍♀️
  • const char * lo_address_get_hostname (lo_address a) — return the hostname of a lo_address object. where do you live 🏠
  • const char * lo_address_get_port (lo_address a) — return the port/service name of a lo_address object. which door 🚪
  • int lo_address_get_protocol (lo_address a) — return the protocol of a lo_address object. how do you travel 🛼
  • char * lo_address_get_url (lo_address a) — return a URL representing an OSC address. link in bio 🔗
  • void lo_address_set_ttl (lo_address t, int ttl) — set the Time-to-Live value for a given target address. how many hops before it gives up 😵
  • int lo_address_get_ttl (lo_address t) — get the Time-to-Live value for a given target address. same but read-only bestie 👀
  • int lo_address_set_iface (lo_address t, const char *iface, const char *ip) — set the network interface to use for a given target address. pick your lane 🛣️
  • const char * lo_address_get_iface (lo_address t) — get the name of the network interface assigned to an OSC address. which lane tho 🧐
  • int lo_address_set_tcp_nodelay (lo_address t, int enable) — set the TCP_NODELAY flag on outgoing TCP connections. no waiting around, we move fast ⚡
  • int lo_address_set_stream_slip (lo_address t, lo_slip_encoding encoding) — set outgoing stream connections (e.g., TCP) to be transmitted using the SLIP packetizing protocol. slipping into something comfy 🩰
  • lo_bundle lo_bundle_new (lo_timetag tt) — create a new bundle object. bundle baby 🎁
  • void lo_bundle_incref (lo_bundle b) — add one to a bundle's reference count. +1 for the bundle 💖
  • int lo_bundle_add_message (lo_bundle b, const char *path, lo_message m) — adds an OSC message to an existing bundle. tuck it in 🍼
  • int lo_bundle_add_bundle (lo_bundle b, lo_bundle n) — adds an OSC bundle to an existing bundle. bundle-ception, nesting era 🪆
  • size_t lo_bundle_length (lo_bundle b) — return the length of a bundle in bytes. 📏
  • unsigned int lo_bundle_count (lo_bundle b) — return the number of top-level elements in a bundle. top-level only, don't count the babies 🔢
  • lo_element_type lo_bundle_get_type (lo_bundle b, int index) — gets the element type contained within a bundle. what even are you 👀
  • lo_bundle lo_bundle_get_bundle (lo_bundle b, int index) — gets a nested bundle contained within a bundle. the bundle inside the bundle 🪆
  • lo_message lo_bundle_get_message (lo_bundle b, int index, const char **path) — gets a message contained within a bundle. found her 🔍
  • lo_timetag lo_bundle_get_timestamp (lo_bundle b) — get the timestamp associated with a bundle. ⏰
  • void * lo_bundle_serialise (lo_bundle b, void *to, size_t *size) — serialise the bundle object to an area of memory and return a pointer to the serialised form. bytes era ✨
  • void lo_bundle_free (lo_bundle b) — frees the memory taken by a bundle object. say bye 👋
  • void lo_bundle_free_recursive (lo_bundle b) — frees the memory taken by a bundle object and its messages and nested bundles recursively. the whole tree, gone, no crumbs 🧹
  • void lo_bundle_free_messages (lo_bundle b) — obsolete, use lo_bundle_free_recursive instead. > she's retired bestie, don't call her 💀
  • int lo_is_numerical_type (lo_type a) — return true if the type specified has a numerical value, such as LO_INT32, LO_FLOAT etc. is it math-coded 🧮
  • int lo_is_string_type (lo_type a) — return true if the type specified has a textual value, such as LO_STRING or LO_SYMBOL. is it word-coded 📝
  • int lo_coerce (lo_type type_to, lo_arg *to, lo_type type_from, lo_arg *from) — attempt to convert one OSC type to another. glow-up transformation 💅
  • lo_hires lo_hires_val (lo_type type, lo_arg *p) — return the numerical value of the given argument with the maximum native system precision. maximum precision, no rounding, we're precise 😤
  • lo_server lo_server_new (const char *port, lo_err_handler err_h) — create a new server instance. hi server 🫶
  • lo_server lo_server_new_with_proto (const char *port, int proto, lo_err_handler err_h) — create a new server instance, specifying protocol. same but you pick the protocol 💅
  • lo_server lo_server_new_multicast (const char *group, const char *port, lo_err_handler err_h) — create a new server instance, and join a UDP multicast group. joining the group chat fr fr 📢
  • lo_server lo_server_new_multicast_iface (const char *group, const char *port, const char *iface, const char *ip, lo_err_handler err_h) — create a new server instance, and join a UDP multicast group, optionally specifying which network interface to use. note that usually only one of iface or ip are specified. pick one, not both, iykyk 😌
  • lo_server lo_server_new_from_url (const char *url, lo_err_handler err_h) — create a new server instance, taking port and the optional multicast group IP from an URL string. everything from the link 🔗
  • lo_server lo_server_new_from_config (lo_server_config *config) — create a new server instance, using a configuration struct. structured and organized 💅
  • int lo_server_enable_coercion (lo_server server, int enable) — enables or disables type coercion during message dispatch. on or off, your call 🔘
  • void lo_server_free (lo_server s) — free up memory used by the lo_server object. bye server 👋
  • int lo_server_wait (lo_server s, int timeout) — wait for an OSC message to be received. sitting pretty, waiting ⌛
  • int lo_servers_wait (lo_server *s, int *status, int num_servers, int timeout) — wait on multiple servers for an OSC message to be received. multitasking queen 👑
  • int lo_server_recv_noblock (lo_server s, int timeout) — look for an OSC message waiting to be received. peek, don't block 👀
  • int lo_servers_recv_noblock (lo_server *s, int *recvd, int num_servers, int timeout) — look for an OSC message waiting to be received on multiple servers. peeking at all of them at once 😭
  • int lo_server_recv (lo_server s) — block, waiting for an OSC message to be received. she will stand there until it arrives, periodt ✋
  • lo_method lo_server_add_method (lo_server s, const char *path, const char *typespec, lo_method_handler h, const void *user_data) — add an OSC method to the specifed server. new method just dropped 🎉
  • void lo_server_del_method (lo_server s, const char *path, const char *typespec) — delete an OSC method from the specified server. method, you're fired 💀
  • int lo_server_del_lo_method (lo_server s, lo_method m) — delete a specific OSC method from the specified server. targeted removal, very specific 🎯
  • int lo_server_add_bundle_handlers (lo_server s, lo_bundle_start_handler sh, lo_bundle_end_handler eh, void *user_data) — add bundle notification handlers to the specified server. start AND end, both notified 🔔
  • int lo_server_get_socket_fd (lo_server s) — return the file descriptor of the server socket. the fd, hand it over 🎫
  • int lo_server_get_port (lo_server s) — return the port number that the server has bound to. which port did she claim 🚪

and bestie, we are NOT done, there's more coming, stay with me 💜

  • int lo_server_get_protocol (lo_server s) — Returns the protocol that the server is using. slay 💅
  • char * lo_server_get_url (lo_server s) — Returns an OSC URL that can be used to contact the server. so handy 🦋
  • int lo_server_enable_queue (lo_server s, int queue_enabled, int dispatch_remaining) — Toggle event queue. If queueing is enabled, timetagged messages that are sent in advance of the current time will be put on an internal queue, and they will be dispatched at the indicated time. By default, queueing is enabled. Use this function to disable it, if it is desired to have a server process messages immediately. In that case, use lo_message_get_timestamp() to get the message timestamp from within a method handler. time vibes ⏰
  • int lo_server_events_pending (lo_server s) — Returns true if there are scheduled events (eg. from bundles) waiting to be dispatched by the server. eyes on the queue 👀
  • double lo_server_next_event_delay (lo_server s) — Returns the time in seconds until the next scheduled event. countdown ⏳
  • int lo_server_max_msg_size (lo_server s, int req_size) — Set the maximum message size accepted by a server. size matters 📏
  • char * lo_url_get_protocol (const char *url) — Returns the protocol portion of an OSC URL, eg. udp, tcp. protocol tea 🔗
  • int lo_url_get_protocol_id (const char *url) — Returns the protocol ID of an OSC URL. ID check 🆔
  • char * lo_url_get_hostname (const char *url) — Returns the hostname portion of an OSC URL. where you at 🏠
  • char * lo_url_get_port (const char *url) — Returns the port portion of an OSC URL. port numbers 🔌
  • char * lo_url_get_path (const char *url) — Returns the path portion of an OSC URL. the path less traveled 🛤️
  • int lo_strsize (const char *s) — A function to calculate the amount of OSC message space required by a C char *. math but make it cute 📐
  • uint32_t lo_blobsize (lo_blob b) — A function to calculate the amount of OSC message space required by a lo_blob object. blob math 🧮
  • int lo_pattern_match (const char *str, const char *p) — Test a string against an OSC pattern glob. matchmaker 🎯
  • int lo_string_contains_pattern (const char *str) — Test if a string contains any OSC pattern characters. detective work 🔍
  • double lo_timetag_diff (lo_timetag a, lo_timetag b) — Find the time difference between two timetags. time math ⏱️
  • void lo_timetag_now (lo_timetag *t) — Return a timetag for the current time. right now ⌚
  • size_t lo_arg_size (lo_type type, void *data) — Return the storage size, in bytes, of the given argument. size of arg 📦
  • char * lo_get_path (void *data, ssize_t size) — Given a raw OSC message, return the message path. path reveal 🛣️
  • void lo_arg_host_endian (lo_type type, void *data) — Convert the specified argument to host byte order where necessary. endian switch 🏠
  • void lo_arg_network_endian (lo_type type, void *data) — Convert the specified argument to network byte order where necessary. network endian 🌐

✨ Detailed Description ✨

Use these functions if you require more precise control over OSC message contruction or handling that what is provided in the high-level functions described in liblo. iykyk 💖

📚 Typedef Documentation 📚

typedef long double lo_hires

Type used to represent numerical values in conversions between OSC types.

Definition at line 56 of file lo_lowlevel.h. fancy precision ✨

🏷️ Enumeration Type Documentation 🏷️

enum lo_slip_encoding

Used with lo_address_set_stream_slip() to specify whether sent messages should be encoded with SLIP, and whether the encoding should be single- or double-ENDed.

Definition at line 85 of file lo_lowlevel.h. slip slidin' 🛷

🛠️ Function Documentation 🛠️

const char * lo_address_get_hostname (lo_address a)

Return the hostname of a lo_address object. Returned value must not be modified or free'd. Value will be a dotted quad, colon'd IPV6 address, or resolvable name. hostname tea 🏠

const char * lo_address_get_iface (lo_address t)

Get the name of the network interface assigned to an OSC address. interface vibes 🖥️

Parameters:

  • t — An OSC address.

Returns:

  • A string pointer or 0 if no interface has been assigned. Caller should not modify the provided string. It is a legal pointer until the next call to lo_address_set_iface or lo_address_free. don't touch 🙅‍♀️

const char * lo_address_get_port (lo_address a)

Return the port/service name of a lo_address object. Returned value must not be modified or free'd. Value will be a service name or ASCII representation of the port number. port please 🔌

int lo_address_get_protocol (lo_address a)

Return the protocol of a lo_address object. Returned value will be one of LO_UDP, LO_TCP or LO_UNIX. protocol check 🔗

int lo_address_get_ttl (lo_address t)

Get the Time-to-Live value for a given target address. TTL baby ⏳

Parameters:

  • t — An OSC address.

Returns:

  • An integer specifying the scope of a multicast UDP message. scope it out 🌐

char * lo_address_get_url (lo_address a)

Return a URL representing an OSC address. Returned value must be free'd. free it later 🗑️

int lo_address_set_iface (lo_address t, const char * iface, const char * ip)

Set the network interface to use for a given target address. The caller should specify either the iface or ip variable. The IP, if specified, should match the same network family as the OSC address. (That is, should correctly correspond to IPv4 or IPv6.) Typically the assigned network interface will only be used in the case of sending multicast messages. It is recommended to use the if_nameindex POSIX function to get a list of network interface names. interface assignment 🛠️

Parameters:

  • t — An OSC address.
  • iface — The name of a network interface on the local system.
  • ip — The IP address of a network interface on the local system.

Returns:

  • 0 if the interface was successfully identified, or non-zero otherwise. zero is good ✅

int lo_address_set_stream_slip (lo_address t, lo_slip_encoding encoding)

Set outgoing stream connections (e.g., TCP) to be transmitted using the SLIP packetizing protocol. slip it 🛷

Parameters:

  • t — The address to set this flag for.
  • encoding — Specify single- or double-ENDed SLIP, or disable SLIP.

Returns:

  • the previous value of this flag. flag history 🚩

int lo_address_set_tcp_nodelay (lo_address t, int enable)

Set the TCP_NODELAY flag on outgoing TCP connections. no delay ⚡

Parameters:

  • t — The address to set this flag for.
  • enable — Non-zero to set the flag, zero to unset it.

Returns:

  • the previous value of this flag. flag check 🚩

void lo_address_set_ttl (lo_address t, int ttl)

Set the Time-to-Live value for a given target address. This is required for sending multicast UDP messages. A value of 1 (the usual case) keeps the message within the subnet, while 255 means a global, unrestricted scope. TTL rules 🌍

Parameters:

  • t — An OSC address.
  • ttl — An integer specifying the scope of a multicast UDP message.

void lo_arg_host_endian (lo_type type, void * data)

Convert the specified argument to host byte order where necessary. endian flip 🔄

Parameters:

  • type — The OSC type of the data item (eg. LO_FLOAT).
  • data — A pointer to the data item to be converted. It is changed in-place.

void lo_arg_network_endian (lo_type type, void * data)

Convert the specified argument to network byte order where necessary. network flip 🌐

Parameters:

  • type — The OSC type of the data item (eg. LO_FLOAT).
  • data — A pointer to the data item to be converted. It is changed in-place.

size_t lo_arg_size (lo_type type, void * data)

Return the storage size, in bytes, of the given argument. size it 📏

uint32_t lo_blobsize (lo_blob b)

A function to calculate the amount of OSC message space required by a lo_blob object. Returns the storage size in bytes, which will always be a multiple of four. blob math 🧮

int lo_bundle_add_bundle (lo_bundle b, lo_bundle n)

Adds an OSC bundle to an existing bundle. The child bundle passed is appended to the list of child bundles|messages in the parent bundle to be dispatched. bundle inception 🎁

Returns:

  • 0 if successful, less than 0 otherwise. zero or bust ✅

int lo_bundle_add_message (lo_bundle b, const char * path, lo_message m)

Adds an OSC message to an existing bundle. The message passed is appended to the list of messages in the bundle to be dispatched to 'path'. message drop 📨

Returns:

  • 0 if successful, less than 0 otherwise. success vibes ✅

unsigned int lo_bundle_count (lo_bundle b)

Return the number of top-level elements in a bundle. count 'em 🔢

Parameters:

  • b — The bundle to be counted.

void lo_bundle_free (lo_bundle b)

Frees the memory taken by a bundle object. free it 🗑️

Parameters:

  • b — The bundle to be freed.

void lo_bundle_free_messages (lo_bundle b)

Obsolete, use lo_bundle_free_recursive instead. old and busted ⚠️

Parameters:

  • b — The bundle, which may contain messages and nested bundles, to be freed.

void lo_bundle_free_recursive (lo_bundle b)

Frees the memory taken by a bundle object and its messages and nested bundles recursively. deep free 🌀

Parameters:

  • b — The bundle, which may contain messages and nested bundles, to be freed.

lo_bundle lo_bundle_get_bundle (lo_bundle b, int index)

Gets a nested bundle contained within a bundle. Returns a lo_bundle at a given index within a bundle. nested bundle 🎁

Returns:

  • The requested lo_bundle if successful, otherwise 0. get it ✅

lo_message lo_bundle_get_message (lo_bundle b, int index, const char ** path)

Gets a message contained within a bundle. Returns a lo_message at a given index within a bundle, and optionally the path associated with that message. message extraction 📩

Returns:

  • The requested lo_message if successful, otherwise 0. got it ✅

lo_timetag lo_bundle_get_timestamp (lo_bundle b)

Get the timestamp associated with a bundle. timestamp tea ⏱️

Parameters:

  • b — The bundle for which the timestamp should be returned.

Returns:

  • The timestamp of the bundle as a lo_timetag. time stamp 🕰️

lo_element_type lo_bundle_get_type (lo_bundle b, int index)

Gets the element type contained within a bundle. Returns a lo_element_type at a given index within a bundle. type check 🔍

Returns:

  • The requested lo_element_type if successful, otherwise 0. type vibes ✅

void lo_bundle_incref (lo_bundle b)

Add one to a bundle's reference count. Bundles are reference counted. If a bundle is multiply referenced, the bundle's counter should be incremented. It is automatically decremented by lo_bundle_free lo_bundle_free_recursive, with lo_bundle_free_recursive being the preferable method. ref count 🔢

size_t lo_bundle_length (lo_bundle b)

Return the length of a bundle in bytes. Includes the marker and typetag length. length check 📏

Parameters:

  • b — The bundle to be sized

lo_bundle lo_bundle_new (lo_timetag tt)

Create a new bundle object. OSC Bundles encapsulate one or more OSC messages and may include a timestamp indicating when the bundle should be dispatched. new bundle who dis 🎁

Parameters:

  • tt — The timestamp when the bundle should be handled by the receiver. Pass LO_TT_IMMEDIATE if you want the receiving server to dispatch the bundle as soon as it receives it.

void * lo_bundle_serialise (lo_bundle b, void * to, size_t * size)

Serialise the bundle object to an area of memory and return a pointer to the serialised form. serialise it 📦

…and we're still deep in that parameter list from the serialise situation, so let's finish it off bestie:

  • b — the bundle to be serialised 🎀
  • to — the address to serialise to, memory will be allocated if to is NULL. yes, it just gives you memory, iconic behaviour.
  • size — if this pointer is non-NULL the size of the memory area will be written here

The returned form is suitable to be sent over a low level OSC transport, having the correct endianess and bit-packed structure. it's giving "ready to ship, no notes" ✨

int lo_coerce (lo_type type_to, lo_arg * to, lo_type type_from, lo_arg * from)

Attempt to convert one OSC type to another. So numerical types (eg. LO_INT32, LO_FLOAT etc.) may be converted to other numerical types, and string types (LO_STRING and LO_SYMBOL) may be converted to the other type. 🦋

This is done automatically if a received message matches the path, but not the exact types, and is coercible (ie. all numerical types in numerical positions). The library is literally doing the vibes-matching for you.

On failure no translation occurs and false is returned. no translation, no crumbs, just false 💀

Parameters

  • type_to — the type of the destination variable.
  • to — a pointer to the destination variable.
  • type_from — the type of the source variable.
  • from — a pointer to the source variable.

char * lo_get_path (void * data, ssize_t size)

Given a raw OSC message, return the message path. 🛣️

Parameters

  • data — a pointer to the raw OSC message data.
  • size — the size of data in bytes (total buffer bytes).

Returns the message path or NULL if an error occurs. Do not free() the returned pointer. it's not yours, it's borrowed, hands off 🙈

lo_hires lo_hires_val (lo_type type, lo_arg * p)

Return the numerical value of the given argument with the maximum native system precision. maximum precision, maximum slay 🔥

int lo_is_numerical_type (lo_type a)

Return true if the type specified has a numerical value, such as LO_INT32, LO_FLOAT etc. 🔢

Parameters

  • a — the type to be tested.

int lo_is_string_type (lo_type a)

Return true if the type specified has a textual value, such as LO_STRING or LO_SYMBOL. 🔤

Parameters

  • a — the type to be tested.

int lo_message_add (lo_message m, const char * types, ...)

Append a number of arguments to a message. The data will be added in OSC byteorder (bigendian). bigendian, we respect her 💜

Parameters

  • m — the message to be extended.
  • types — the types of the data items in the message, types are defined in lo_types_common.h
  • ... — the data values to be transmitted. The types of the arguments passed here must agree with the types specified in the type parameter. they MUST agree, this is not a vibe-based negotiation

Returns

  • Less than 0 on failure, 0 on success. ✨

int lo_message_add_blob (lo_message m, lo_blob a)

Append a data item and typechar of the specified type to a message. See lo_message_add_int32() for details. 🫶

Returns

  • Less than 0 on failure, 0 on success.

int lo_message_add_char (lo_message m, char a)

Append a data item and typechar of the specified type to a message. See lo_message_add_int32() for details. 🎀

Returns

  • Less than 0 on failure, 0 on success.

int lo_message_add_double (lo_message m, double a)

Append a data item and typechar of the specified type to a message. See lo_message_add_int32() for details. 💫

Returns

  • Less than 0 on failure, 0 on success.

int lo_message_add_false (lo_message m)

Append a data item and typechar of the specified type to a message. See lo_message_add_int32() for details. no arguments, just vibes and a false

Returns

  • Less than 0 on failure, 0 on success.

int lo_message_add_float (lo_message m, float a)

Append a data item and typechar of the specified type to a message. See lo_message_add_int32() for details. 🌸

Returns

  • Less than 0 on failure, 0 on success.

int lo_message_add_infinitum (lo_message m)

Append a data item and typechar of the specified type to a message. See lo_message_add_int32() for details. ♾️ it's giving infinity, literally in the name

Returns

  • Less than 0 on failure, 0 on success.

int lo_message_add_int32 (lo_message m, int32_t a)

Append a data item and typechar of the specified type to a message. The data will be added in OSC byteorder (bigendian). ⭐ this is the blueprint, the moment, the template all the other add girls reference

Parameters

  • m — the message to be extended.
  • a — the data item.

Returns

  • Less than 0 on failure, 0 on success.

int lo_message_add_int64 (lo_message m, int64_t a)

Append a data item and typechar of the specified type to a message. See lo_message_add_int32() for details. 🦋

Returns

  • Less than 0 on failure, 0 on success.

int lo_message_add_midi (lo_message m, uint8_t a[4])

Append a data item and typechar of the specified type to a message. See lo_message_add_int32() for details. 🎹 four whole bytes of MIDI, cute

Returns

  • Less than 0 on failure, 0 on success.

int lo_message_add_nil (lo_message m)

Append a data item and typechar of the specified type to a message. See lo_message_add_int32() for details. 💀 nil, the void, the nothingness, iconic

Returns

  • Less than 0 on failure, 0 on success.

int lo_message_add_string (lo_message m, const char * a)

Append a data item and typechar of the specified type to a message. See lo_message_add_int32() for details. 🍓

Returns

  • Less than 0 on failure, 0 on success.

int lo_message_add_symbol (lo_message m, const char * a)

Append a data item and typechar of the specified type to a message. See lo_message_add_int32() for details. 🎀

Returns

  • Less than 0 on failure, 0 on success.

int lo_message_add_timetag (lo_message m, lo_timetag a)

Append a data item and typechar of the specified type to a message. See lo_message_add_int32() for details. ⏰

Returns

  • Less than 0 on failure, 0 on success.

int lo_message_add_true (lo_message m)

Append a data item and typechar of the specified type to a message. See lo_message_add_int32() for details. ✅

Returns

  • Less than 0 on failure, 0 on success.

int lo_message_add_varargs (lo_message m, const char * types, va_list ap)

Append a varargs list to a message. The data will be added in OSC byteorder (bigendian).

IMPORTANT: args list must be terminated with LO_ARGS_END, or this call will fail. This is used to do simple error checking on the sizes of parameters passed. do not forget LO_ARGS_END. do NOT. it will fail and you will be sad. 😭

Parameters

  • m — the message to be extended.
  • types — the types of the data items in the message, types are defined in lo_types_common.h
  • ap — the va_list created by a C function declared with an ellipsis (...) argument, and pre-initialised with "va_start(ap)". The types of the arguments passed here must agree with the types specified in the type parameter.

Returns

  • Less than 0 on failure, 0 on success.

void lo_message_clear (lo_message m)

Clear elements from a lo_message but do not free allocated memory. 🧹 cleared, but the memory is still there living its life — this is not a free

lo_message lo_message_clone (lo_message m)

Create a new lo_message object by cloning an already existing one. 🫶 two of them. twins. matching energy.

int lo_message_decref (lo_message m)

Subtract one from a message's reference count. Messages are reference counted. In general decrementing the counter should be handled automatically using lo_message_free or lo_bundle_free_recursive, however if necessary the counter can be decremented manually. 💅 you can do it by hand, but like, why would you when the automatic way exists

lo_message lo_message_deserialise (void * data, size_t size, int * result)

Deserialise a raw OSC message and return a new lo_message object. Opposite of lo_message_serialise(). 🔄

Parameters

  • data — pointer to the raw OSC message data in network transmission form (network byte order where appropriate).
  • size — the size of data in bytes
  • result — if this pointer is non-NULL, the result or error code will be written here.

Returns a new lo_message, or NULL if deserialisation fails. Use lo_message_free() to free the resulting object. and yes, you HAVE to free it. it's yours now, you're responsible. 👑

void lo_message_free (lo_message m)

Free memory allocated by lo_message_new() and any subsequent lo_message_add_int32 lo_message_add*() calls. 🗑️ closure, finally

int lo_message_get_argc (lo_message m)

Return the message argument count. The result is valid until further data is added with lo_message_add*(). ⚠️ valid until you add more stuff — it is not forever, bestie

lo_arg ** lo_message_get_argv (lo_message m)

Return the message arguments. Do not free the returned data. The result is valid until further data is added with lo_message_add*(). 🙈 borrowed data, hands off, and again: only valid until the next lo_message_add*()

lo_address lo_message_get_source (lo_message m)

Returns the source (lo_address) of an incoming message. Returns NULL if the message is outgoing. Do not free the returned address.

This is usually called on the lo_message passed to lo_method_handler, to set up bidirectional communication. See example_tcp_echo_server.c for an example of this. 🌈 this is the one that lets you talk BACK, two-way conversation energy

lo_timetag lo_message_get_timestamp (lo_message m)

Returns the timestamp (lo_timetag *) of a bundled incoming message. Returns LO_TT_IMMEDIATE if the message is outgoing, or did not arrive contained in a bundle. Do not free the returned timetag. ⏱️

char * lo_message_get_types (lo_message m)

Return the message type tag string. The result is valid until further data is added with lo_message_add*(). 🏷️ same rule as always: valid until the next add

void lo_message_incref (lo_message m)

Add one to a message's reference count. Messages are reference counted. If a message is multiply referenced, the message's counter should be incremented. It is automatically decremented by lo_message_free or lo_bundle_free_recursive, with lo_bundle_free_recursive being the preferable method if bundles are used. 👑 multiply referenced = increment. that's the whole tea.

size_t lo_message_length (lo_message m, const char * path)

Return the length of a message in bytes. 📏

Parameters

  • m — the message to be sized
  • path — the path the message will be sent to

lo_message lo_message_new (void )

Create a new lo_message object. ✨ fresh out the box, brand new, no notes

void * lo_message_serialise (lo_message m, const char * path, void * to, size_t * size)

Serialise the lo_message object to an area of memory and return a pointer to the serialised form. Opposite of lo_message_deserialise(). 🔄

Parameters

  • m — the message to be serialised
  • path — the path the message will be sent to
  • to — the address to serialise to, memory will be allocated if to is NULL.
  • size — if this pointer is non-NULL the size of the memory area will be written here

The returned form is suitable to be sent over a low level OSC transport, having the correct endianess and bit-packed structure. 💖

int lo_pattern_match (const char * str, const char * p)

Test a string against an OSC pattern glob. 🌸

Parameters

  • str — the string to test
  • p — the pattern to test against

Returns

  • 1 if true, 0 otherwise. one or zero, that's it, that's the answer

int lo_send_bundle (lo_address targ, lo_bundle b)

Send a lo_bundle object to address targ. Bundles are constructed with the lo_bundle_new() and lo_bundle_add_message() functions. 🎁 you gotta BUILD the bundle first, this girl only ships it

int lo_send_bundle_from (lo_address targ, lo_server serv, lo_bundle b)

Send a lo_bundle object to address targ from address of serv. Bundles are constructed with the lo_bundle_new() and lo_bundle_add_message() functions. 🚀

Parameters

  • targ — the address to send the bundle to
  • serv — the server socket to send the bundle from (can be NULL to use new socket)
  • b — the bundle itself

lo_send_message()

int lo_send_message (lo_address targ, const char * path, lo_message msg)

okay so bestie, this one ships a whole lo_message object off to the target targ 🎀. It's slightly more efficient than lo_send() when you're sending a lot of similar messages — which, if that's your whole vibe, slay. You build those messages with the lo_message_new() and lo_message_add*() functions. 💅

lo_send_message_from()

int lo_send_message_from (lo_address targ, lo_server serv, const char * path, lo_message msg)

same energy as above but it sends a lo_message object to targ from the address of serv ✨. Also slightly more efficient than lo_send() when you've got a whole pile of similar messages to push out. Messages get built with lo_message_new() and lo_message_add*(). 💖

Parameters

  • targ — the address you're sending the message to 🫶
  • serv — the server socket to send the message from (can be NULL to use a new socket) 🦋
  • path — the path to send the message to
  • msg — the bundle itself 👑

lo_server_add_bundle_handlers()

int lo_server_add_bundle_handlers (lo_server s, lo_bundle_start_handler sh, lo_bundle_end_handler eh, void * user_data)

adds bundle notification handlers to the server you point at, no cap 🔔. You get told when a bundle starts and when it's done, which is very main-character of you.

Parameters

  • s — the server the method is to be added to 🌸
  • sh — the callback function that gets called before the messages of a bundle are dispatched
  • eh — the callback function that gets called after the messages of a bundle are dispatched
  • user_data — a value that gets passed to the user_data parameter of both callback functions 💜

lo_server_add_method()

lo_method lo_server_add_method (lo_server s, const char * path, const char * typespec, lo_method_handler h, const void * user_data)

registers an OSC method on the specified server ✨ iconic behaviour honestly.

Parameters

  • s — the server the method is to be added to 🎀
  • path — the OSC path to register the method to. If NULL is passed, the method will match all paths 👑
  • typespec — the typespec the method accepts. Incoming messages with similar typespecs (e.g. ones with numerical types in the same position) will be coerced to the typespec given here 🦋
  • h — the method handler callback function that gets called if a matching message is received 💖
  • user_data — a value that gets passed to the callback function h when it's invoked matching from this method 🫶

Returns

A unique pointer identifying the method. > It should not be freed. 💀 do NOT free it bestie, I'm begging.

lo_server_del_lo_method()

int lo_server_del_lo_method (lo_server s, lo_method m)

deletes one specific OSC method from the server you name 🧹 bye girl.

Parameters

  • s — the server the method is to be removed from
  • m — the lo_method identifier returned from lo_server_add_method for the method to delete from the server 🌸

Returns

Non-zero if it was not found in the list of methods for the server. 💀

lo_server_del_method()

void lo_server_del_method (lo_server s, const char * path, const char * typespec)

deletes an OSC method from the server you specify 🦋.

Parameters

  • s — the server the method is to be removed from
  • path — the OSC path of the method to delete. If NULL is passed, the method will match the generic handler ✨
  • typespec — the typespec the method accepts 💜

lo_server_dispatch_data()

int lo_server_dispatch_data (lo_server s, void * data, size_t size)

dispatches a raw block of memory that contains an OSC message 📦. This is genuinely so useful: if you've got a raw block of memory sitting there structured as OSC, and you want liblo to dispatch the message to a handler function as if it had been received over the network, this is your girl. 💅

Parameters

  • s — the lo_server to use for dispatching
  • data — pointer to the raw OSC message data in network transmission form (network byte order where appropriate) 🌈
  • size — the size of data in bytes

Returns the number of bytes used if successful, or less than 0 otherwise. 😭

lo_server_enable_coercion()

int lo_server_enable_coercion (lo_server server, int enable)

turns type coercion during message dispatch on or off 🎚️.

Parameters

  • server — the server to toggle this option for
  • enable — non-zero to enable, or zero to disable type coercion ✨

Returns

The previous value of this option 👑

lo_server_enable_queue()

int lo_server_enable_queue (lo_server s, int queue_enabled, int dispatch_remaining)

toggles the event queue 🕰️. If queueing is enabled, timetagged messages sent in advance of the current time get put on an internal queue and dispatched at the indicated time. By default, queueing is enabled. Use this function to disable it if you want the server to process messages immediately — in that case, use lo_message_get_timestamp() to get the message timestamp from within a method handler. 🦋

Parameters

  • s — a liblo server
  • queue_enabled — zero to disable queue, non-zero to enable
  • dispatch_remaining — if non-zero, previously queued messages will be immediately dispatched when the queue is disabled ⚡

Returns

The previous state of queue behaviour. Zero if queueing was previously disabled, non-zero otherwise 💜

lo_server_events_pending()

int lo_server_events_pending (lo_server s)

returns true if there are scheduled events (eg. from bundles) waiting to be dispatched by the server 👀✨

lo_server_free()

void lo_server_free (lo_server s)

frees up the memory used by the lo_server object 🧹🫶

📎 Referenced by lo::Server::~Server().

lo_server_get_port()

int lo_server_get_port (lo_server s)

returns the port number the server has bound to 🔢. Super handy when you passed NULL for the port number and now you're sitting there like "okay but how do I even address this server" — this tells you. 💅

lo_server_get_protocol()

int lo_server_get_protocol (lo_server s)

returns the protocol the server is using 🌐. The value you get back will be one of LO_UDP, LO_TCP or LO_UNIX.

lo_server_get_socket_fd()

int lo_server_get_socket_fd (lo_server s)

returns the file descriptor of the server socket 🎀. If the server protocol supports exposing the server's underlying receive mechanism for monitoring with select() or poll(), this function returns the file descriptor you need — otherwise it returns -1. 😭

⚠️ WARNING: when you use this function, beware that not all OSC packets that are received are dispatched immediately. lo_server_events_pending() and lo_server_next_event_delay() can be used to tell if there are pending events and how long before you should attempt to receive them. 👑

lo_server_get_url()

char * lo_server_get_url (lo_server s)

returns an OSC URL you can use to contact the server 🔗✨. The return value should be free()'d when it's no longer needed — don't be a memory leaker bestie, that's not the vibe. 💅

lo_server_max_msg_size()

int lo_server_max_msg_size (lo_server s, int req_size)

sets the maximum message size the server will accept 📏. For UDP servers, the maximum message size cannot exceed 64k, thanks to the UDP transport specifications. For TCP servers the number can be larger, but be aware that one or more contiguous blocks of memory of this size may be allocated by liblo — at least one per connection. 😭

Parameters

  • s — the server on which to operate
  • req_size — the new maximum message size to request, 0 if it should not be modified, or -1 if it should be set to unlimited. > 💀 Note that an unlimited message buffer may make your application open to a denial of service attack.

Returns

The new maximum message size is returned, which may or may not be equal to req_size. If -1 is returned, maximum size is unlimited. 🦋

lo_server_new()

lo_server lo_server_new (const char * port, lo_err_handler err_h)

creates a shiny new server instance ✨. Using lo_server_recv(), lo_servers block until they receive OSC messages — which, ngl, is usually not what you want. Most likely you're after non-blocking behaviour, so use of lo_server_recv_noblock() is encouraged, or go with the lo_server_thread_new and "lo_server_thread_*" functions. 💅

Parameters

  • port — if NULL is passed, then an unused UDP port will be chosen by the system, and its number may be retrieved with lo_server_thread_get_port() so it can be passed to clients 🎀. Otherwise a decimal port number, service name or UNIX domain socket path may be passed 🌸
  • err_h — an error callback function that will be called if there is an error in message reception or server creation. Pass NULL if you do not want error handling 🙈
📎 Referenced by lo::Server::Server(), and lo::Server::Server().

lo_server_new_from_config()

lo_server lo_server_new_from_config (lo_server_config * config)

creates a new server instance, using a configuration struct 🛠️✨.

Parameters

  • config — a pre-initialized config struct. > 💜 A pointer to it will not be kept.

Returns

A new lo_server instance 👑

lo_server_new_from_url()

lo_server lo_server_new_from_url (const char * url, lo_err_handler err_h)

creates a new server instance, taking the port and the optional multicast group IP from an URL string 🔗🌈.

Parameters

  • url — the URL to specify the server parameters
  • err_h — an error callback function that will be called if there is an error in message reception or server creation. Pass NULL if you do not want error handling 🙈

Returns

A new lo_server instance 🎀

lo_server_new_multicast()

lo_server lo_server_new_multicast (const char * group, const char * port, lo_err_handler err_h)

creates a new server instance and joins a UDP multicast group 🫂✨ iconic.

Parameters

  • group — the multicast group to join. See documentation on IP multicast for the acceptable address range; e.g., http://tldp.org/HOWTO/Multicast-HOWTO-2.html 🌐
  • port — if using UDP then NULL may be passed to find an unused port. Otherwise a decimal port number or service name may be passed. If using UNIX domain sockets then a socket path should be passed here 🦋
  • err_h — an error callback function that will be called if there is an error in message reception or server creation. Pass NULL if you do not want error handling 🙈
📎 Referenced by lo::Server::Server().

lo_server_new_multicast_iface()

lo_server lo_server_new_multicast_iface (const char * group, const char * port, const char * iface, const char * ip, lo_err_handler err_h)

creates a new server instance and joins a UDP multicast group, optionally specifying which network interface to use 💅. > 📌 Note that usually only one of iface or ip are specified.

Parameters

  • group — the multicast group to join. See documentation on IP multicast for the acceptable address range; e.g., http://tldp.org/HOWTO/Multicast-HOWTO-2.html 🌐
  • port — if using UDP then NULL may be passed to find an unused port. Otherwise a decimal port number or service name may be passed. If using UNIX domain sockets then a socket path should be passed here 🦋
  • iface — a string specifying the name of a network interface to use, or zero if not specified 🎀
  • ip — a string specifying the IP address of a network interface to use, or zero if not specified ⭐
  • err_h — an error callback function that will be called if there is an error in message reception or server creation. Pass NULL if you do not want error handling 🙈
📎 Referenced by lo::Server::Server(), and lo::Server::Server().

💫 lo_server_new_with_proto

lo_server lo_server_new_with_proto (const char * port, int proto,
    lo_err_handler err_h)

okay so bestie, this is where you build a whole new server instance and you get to say which protocol it speaks. periodt. here's the thing though — if you use lo_server_recv(), your lo_servers are gonna block until an OSC message shows up, which is giving "waiting by the phone forever" energy 😭. most likely you want the non-blocking vibe, so the docs are literally begging you to use lo_server_recv_noblock() or go hang out with lo_server_thread_new and all the lo_server_thread_* functions instead. 👑

Parameters

  • port — if you're doing UDP, you can pass NULL and it'll find an unused port for you, iconic. otherwise pass a decimal port number or a service name, or... a socket path, if you're on UNIX domain sockets. slay.
  • proto — the protocol, and it should be one of LO_UDP, LO_TCP or LO_UNIX. pick your fighter.
  • err_h — an error callback function that gets called if something goes wrong with message reception or server creation. pass NULL if you do not want error handling (bold move, but okay 🫶).

Referenced by lo::Server::Server(), and lo::Server::Server(). (yes it's listed twice, no we're not questioning it 💅)

⏰ lo_server_next_event_delay

double lo_server_next_event_delay (lo_server s)

gives you the time in seconds until the next scheduled event. and if that delay is greater than 100 seconds? it just returns 100.0. capped, humble, lowkey. ✨

📥 lo_server_recv

int lo_server_recv (lo_server s)

this one blocks — just sits there waiting for an OSC message to arrive. and honestly? that blocking behavior is, in most cases, undesireable, because a program with no incoming messages may literally never exit 💀. it is encouraged to use lo_server_recv_noblock() instead, which is equivalent to lo_server_wait() and then lo_server_recv(). do that. please.

the return value is the number of bytes in the received message. the message will be dispatched to a matching method if one is found. and in cases where no message is received but you need to return anyway, this function may return 0. okay so basically never trust it to be a real message, iykyk.

🦋 lo_server_recv_noblock

int lo_server_recv_noblock (lo_server s, int timeout)

looks for an OSC message waiting to be received. in new programs, this function should be prefered over lo_server_recv(). this is the main character of message receiving, fr fr. 🌟

Parameters

  • s — the server to wait for connections on.
  • timeout — a timeout in milliseconds to wait for the incoming packet. a value of 0 will return immediately.

the return value is the number of bytes in the received message, or 0 if there is no message. the message will be dispatched to a matching method if one is found. no message, no problem. 🎀

⏳ lo_server_wait

int lo_server_wait (lo_server s, int timeout)

wait for an OSC message to be received. simple. elegant. iconic.

Parameters

  • s — the server to wait for connections on.
  • timeout — a timeout in milliseconds to wait for the incoming packet. a value of 0 will return immediately.

the return value is 1 if there is a message waiting, 0 if there is no message, and -1 if there is an error that causes the function to return early. if there is a message waiting you can now call lo_server_recv() to receive that message. and this is preferable to using lo_server_recv() alone, since otherwise it may never exit if no new messages are incoming. the way that waiting is a whole strategy 😭✨

🫶 lo_servers_recv_noblock

int lo_servers_recv_noblock (lo_server * s, int * recvd, int num_servers,
    int timeout)

look for an OSC message waiting to be received on multiple servers. yes bestie, plural. we're multithreading the vibe.

Parameters

  • s — as array of servers to wait for connections on.
  • recvd — an array to store the number of bytes received by each server in array s.
  • num_servers — the number of servers in the array s.
  • timeout — a timeout in milliseconds to wait for the incoming packet. a value of 0 will return immediately.

the return value is the total number of bytes received by all servers. the messages will be dispatched to a matching method if one is found. 💖

🌸 lo_servers_wait

int lo_servers_wait (lo_server * s, int * status, int num_servers, int
    timeout)

wait on multiple servers for an OSC message to be received. one wait, many servers, we love efficiency.

Parameters

  • s — an array of servers to wait for connections on.
  • status — an array to receive the status of each server.
  • num_servers — the number of servers in the array s.
  • timeout — a timeout in milliseconds to wait for the incoming packet. a value of 0 will return immediately.

the return value is the number of servers with a message waiting, or -1 if there is an error that causes the function to return early. if there is a message waiting you can now call lo_server_recv() to receive that message. this is preferable to using lo_server_recv() alone, since otherwise it may never exit if no new messages are incoming. (yes it says that again. consistency queen. 👑)

🔍 lo_string_contains_pattern

int lo_string_contains_pattern (const char * str)

test if a string contains any OSC pattern characters. pattern check, vibe check, same thing really.

Parameters

  • str — the string to test

Returns 1 if true, 0 otherwise. binary, unbothered, moisturized.

📏 lo_strsize

int lo_strsize (const char * s)

a function to calculate the amount of OSC message space required by a C char *. returns the storage size in bytes, which will always be a multiple of four. always. no cap. the alignment is aligned. ✨

🕰️ lo_timetag_diff

double lo_timetag_diff (lo_timetag a, lo_timetag b)

find the time difference between two timetags. returns a - b in seconds. note the order, bestie — it's a minus b, not the other way around 🙈.

⏱️ lo_timetag_now

void lo_timetag_now (lo_timetag * t)

return a timetag for the current time. on exit the timetag pointed to by t is filled with the OSC representation of this instant in time. this exact moment. captured. ✨

Referenced by lo::now().

🌐 lo_url_get_hostname

char * lo_url_get_hostname (const char * url)

return the hostname portion of an OSC URL. and listen — the return value should be free()'d when it is no longer needed. do not forget. do not leak. 🫶

🛤️ lo_url_get_path

char * lo_url_get_path (const char * url)

return the path portion of an OSC URL. again: the return value should be free()'d when it is no longer needed. memory hygiene is self care. 💅

🔌 lo_url_get_port

char * lo_url_get_port (const char * url)

return the port portion of an OSC URL. and yep, you already know — the return value should be free()'d when it is no longer needed.

📡 lo_url_get_protocol

char * lo_url_get_protocol (const char * url)

return the protocol portion of an OSC URL, eg. udp, tcp. this library uses OSC URLs of the form:

osc.prot://hostname:port/path

if the prot part is missing, UDP is assumed. classic default behavior, lowkey relatable.

the return value should be free()'d when it is no longer needed. yes. again. free it. 🎀

🏷️ lo_url_get_protocol_id

int lo_url_get_protocol_id (const char * url)

return the protocol ID of an OSC URL. this library uses OSC URLs of the form:

osc.prot://hostname:port/path

if the prot part is missing, UDP is assumed. returned value will be one of LO_UDP, LO_TCP, LO_UNIX or -1.

Returns an integer specifying the protocol. return -1 when the protocol is not supported by liblo. so if you get -1, that protocol said "not me" 🙈.

👑 Author

Generated automatically by Doxygen for liblo from the source code. (the robots wrote it, we just gave it the group chat glow-up ✨)

and that's a wrap on liblolowlevel(3), bestie! this page came to you from liblo, Version 0.34, and it's dated the same as always on this man page — go forth and free() your strings, avoid blocking calls, and slay your OSC servers responsibly 💖🦋🎀🫶✨

📦 where this page comes from