Programming a c application which is calling a *.so built by LabVIEW.

Question

Hello all,
This question probably has been asked, but I can't find the answer.  So here's my question:
I have built a LabVIEW *.so in Linux and I want to call it from a "c" application.  The LabVIEW *.so is returning a cluster of strings and I want to know how to call it from my c application (memory allocation?).
Here's the *.so source code, the function is named "testvi":
Here's my c application source code:
#include <stdio.h>
#include <string.h>
#include "testclusterofstrings.h"
int main()
Cluster_Of_Strings clusterofstrings;
Testvi(&clusterofstrings);
printf("-------------\n");
printf("String_A: %s", (*clusterofstrings.String_A)->str);
printf("-------------\n");
return 0;
I'm getting the following output when calling my application:
LabVIEW caught fatal signal
13.0 - Received SIGSEGV
Reason: address not mapped to object
Attempt to reference address: 0x0x19f5c381
Segmentation fault (core dumped)
So, what is the proper way to do this?
Thanks,
Michel
Solved!
Go to Solution.

Answer 1

smithd wrote:
If its a labview-built dll and you're passing parameters by ref, I'm not too surprised you have to initialize it (although I would expect labview to be friendly enough to allocate the data structures for you). Maybe if you passed it a null pointer instead it would work? From your original post, maybe try this:
int main() {
Cluster_Of_Strings * clusterofstrings = NULL;
Testvi(clusterofstrings);
For some reason I remember reading that labview will interpret the null as a sign that it needs to allocate the structure, but I could be totally insane on that point.
If that doesn't work, then yes you'll have to allocate all the handles as appropriate. From <labview>\cintools\extcode.h you can see that a string is defined as follows:
typedef struct {
int32 cnt; /* number of bytes that follow */
uChar str[1]; /* cnt bytes */
} LStr, *LStrPtr, **LStrHandle;
Since you have size-0 arrays I think you really just need to call DSNewHClr(sizeof(int32)) which will allocate a handle with all 0s, and 0 is what you want. Final result would be...
int main()
Cluster_Of_Strings MeasInfo;
MeasInfo.String_A = (LStrHandle)DSNewHClr(sizeof(int32));
MeasInfo.String_B = (LStrHandle)DSNewHClr(sizeof(int32));
Testvi(&MeasInfo);
 Oh, and for the string functions, make sure you look at the built-in functions first before you make your own.
Actually, the whole thing is both a little easier and more complicated at the same time. LabVIEW is fully managed with its data types but you have to follow that management contract when you interface to LabVIEW code from C.
First, the first attempt with allocating a string handle with sizeof(int32) + sizeof(uChar) bytes without initializing the length element is wrong. That length element could contain any value and cause LabVIEW to wrongly assume that the handle is already big enough to fill in its data and not do anything and then writing over the end of the allocated buffer.
Also initialisation of the structure with NULL is not going to work. This cluster has to be provided by the caller as it is a fixed size data area passed in as a pointer. However initialisation of the string handles inside the cluster with NULL should work fine, since LabVIEW considers NULL handles as the canonical zero length handle.
However after you have called the LabVIEW DLL function you are the owner of any memory that was allocated by that function and returned to you, just as you would be if you had allocated those handles yourself before the call. So proper etiquete is to also deallocate it and this is not optional but a requirement or you create memory leaks. It doesn't get noticed here since your test program terminates anyhow right after but it will bite you badly in a bigger application if you forget this.
The code could then look something like this:
int main()
Cluster_Of_Strings MeasInfo;
MeasInfo.String_A = NULL;
MeasInfo.String_B = NULL;
Testvi(&MeasInfo);
printf("-------------\n");
printf("String_A: %s\n", LV_str_to_C_str(MeasInfo.String_A));
printf("String_B: %s\n", LV_str_to_C_str(MeasInfo.String_B));
printf("size %d", (sizeof(int32) + sizeof(uChar)));
printf("-------------\n");
  if (MeasInfo.String_A)
DSDisposeHandle(MeasInfo.String_A);
if (MeasInfo.String_B)
DSDisposeHandle(MeasInfo.String_B);
return 0;
// Returns the pointer to the string buffer in a LabVIEW string handle that has been made
// sure to be zero terminated.
char *LV_str_to_C_str(LStrHandle lv_str)
if (lv_str && !NumericArrayResize(uB, 1, (UHandle*)&lv_str, LStrLen(*lv_str) + 1))
LStrBuf(*lv_str)[LStrLen(*lv_str)] = 0;
return LStrBuf(*lv_str);
return NULL;
Rolf Kalbermatter
CIT Engineering Netherlands
a division of Test & Measurement Solutions