How to use lisp packages from libraries?

[Иван Трусков]

I am trying to use a package function in my lisp library that will
later be called from a C application. To be precise, it is shorten
function from the str package.

Here is my lisp library text:

;; (require :str)
;; (use-package :str)

(defun echo-string (s)
  (coerce (format nil "Recieved input: ~10A" (shorten-string s)) 'base-string))

(defun shorten-string (s)
  (declare (string s))
  (let ((l (length s)))
    (if (> l 10)
        (concat (shorten 7 s) (substring (- l 3) nil s))
        s)))

First lines are commented out because i do not know their necessity in
the library. That's part of the question.

However, all i get when trying to use any function from this library
is a number of undecipherable errors, like this:

https://pastebin.com/Sn8jgE9f

Here is my C code for a minimal case:

#include <stdlib.h>
#include <stdio.h>
#include <ecl/ecl.h>

// utility functions

cl_object make_cl_string(const char * pstring)
{
    return ecl_make_constant_base_string(pstring, strlen(pstring));
}

int main(int argc, const char* argv[])
{
   /* Initialize ECL */
   ecl_set_option(ECL_OPT_TRAP_SIGSEGV, false);
   cl_boot(argc, argv);

   extern void init_lib_ASDF(cl_object);
   ecl_init_module(NULL, init_lib_ASDF);

   // is this necessary?
   extern void init_lib_ECL_QUICKLISP(cl_object);
   ecl_init_module(NULL, init_lib_ECL_QUICKLISP);
   cl_object ecl_module_name = make_cl_string("ecl-quicklisp");
   cl_require(1, ecl_module_name);
   cl_object str_module_name = make_cl_string("str");
   cl_require(1, str_module_name);
   // this code fails, not clear what use as package designator
   /* cl_object str_package_name = make_cl_string(":str"); */
   /* cl_use_package(1, str_package_name); */
   extern void init_embedded_console(cl_object);
   ecl_init_module(NULL, init_embedded_console);

   // library calls
   cl_object fname = make_cl_string("ECHO-STRING");
   cl_object echo_func = cl_find_symbol(1, fname);
   assert(ECL_SYMBOLP(pstate->echo_func));

   const char * line = "hello";
   cl_object call_result = cl_funcall(2, echo_func, make_cl_string(line));
   char * msg_str = malloc(call_result->string.fillp + 1);
   memcpy(msg_str, call_result->string.self, call_result->string.fillp + 1);
   printf("Output: %s\n", msg_str);
   free(msg_str);

   const char * line2 = "hello";
   call_result = cl_funcall(2, echo_func, make_cl_string(line2));
   msg_str = malloc(call_result->string.fillp + 1);
   memcpy(msg_str, call_result->string.self, call_result->string.fillp + 1);
   printf("Output: %s\n", msg_str);
   free(msg_str);

   return 0;
}


What should be done for me to be able to use some package (installed
with quicklisp) from my ECL library? How should the initialisation be
done?