intro man page on OpenIndiana

Man page or keyword search:  
man Server   20441 pages
apropos Keyword Search (all sections)
Output format
OpenIndiana logo
[printable version]

Intro(3)	       Introduction to Library Functions	      Intro(3)

NAME
       Intro, intro - introduction to functions and libraries

DESCRIPTION
       This  section  describes	 functions found in various Solaris libraries,
       other than those functions described in Section 2 of this  manual  that
       directly	 invoke	 UNIX  system primitives. Function declarations can be
       obtained from the #include files indicated  on  each  page.  Pages  are
       grouped by library and are identified by the library name (or an abbre‐
       viation of the library name) after the section number.  Collections  of
       related	libraries  are	grouped	 into  volumes as described below. The
       first volume contains pages describing  the  contents  of  each	shared
       library	and  each  header  used by the functions, macros, and external
       variables described in the remaining volumes.

   Library Interfaces and Headers
       This volume describes the contents of  each  shared  library  and  each
       header  used  by functions, macros, and external variables described in
       the remaining volumes.

       (3LIB)

	   The libraries described in this section are implemented  as	shared
	   objects.

	   Descriptions	 of  shared  objects  can  include a definition of the
	   global symbols that define the shared  objects'  public  interface,
	   for	example SUNW_1.1. Other interfaces can exist within the shared
	   object, for example SUNWprivate.1.1. The public interface  provides
	   a stable, committed set of symbols for application development. The
	   private interfaces are for internal use only, and could  change  at
	   any time.

       (3HEAD)

	   The	headers	 described  in	this  section  are  used by functions,
	   macros, and external variables.  Headers  contain  function	proto‐
	   types,  definitions	of symbolic constants, common structures, pre‐
	   processor macros, and defined types. Each function described in the
	   remaining  five  volumes  specifies the headers that an application
	   must include in order to use that function. In most cases only  one
	   header  is  required.  These	 headers are present on an application
	   development system; they do have to be present on the target execu‐
	   tion system.

   Basic Library Functions
       The functions described in this volume are the core C library functions
       that are basic to application development.

       (3C)

	   These functions, together with those of Section 2,  constitute  the
	   standard  C	library,  libc, which is automatically linked by the C
	   compilation system. The standard C  library	is  implemented	 as  a
	   shared  object, libc.so. See libc(3LIB) and the "C Compilation Sys‐
	   tem" chapter of the ANSI C Programmer's  Guide  for	a  discussion.
	   Some	 functions  behave differently in standard-conforming environ‐
	   ments. This behavior is noted on the individual manual  pages.  See
	   standards(5).

	   The libpthread and libthread libraries are filter libraries on libc
	   that are used for building multithreaded  applications:  libpthread
	   implements  the POSIX (see standards(5)) threads interface, whereas
	   libthread implements the  Solaris  threads  interface.  See	MULTI‐
	   THREADED APPLICATIONS, below.

       (3C_DB)

	   These  functions constitute the threads debugging library, libc_db.
	   This library is implemented as a shared object, libc_db.so, but  is
	   not	automatically  linked  by  the	C  compilation system. Specify
	   -lc_db on the cc command  line  to  link  with  this	 library.  See
	   libc_db(3LIB).

       (3MALLOC)

	   These functions constitute the various memory allocation libraries:
	   libmalloc, libbsdmalloc, libmapmalloc,  libmtmalloc,	 and  libumem.
	   Each	 of these libraries is implemented as a shared object (libmal‐
	   loc.so,  libbsdmalloc.so,  libmapmalloc.so,	 libmtmalloc.so,   and
	   libumem.so).	 These libraries are not automatically linked by the C
	   compilation system.	Specify	 -lmalloc,  -lbsdmalloc,  -lmapmalloc,
	   -lmtmalloc, and -lumem to link with, respectively, libmalloc, libb‐
	   sdmalloc,  libmapmalloc,  libmtmalloc,  and	libumem.  See  libmal‐
	   loc(3LIB),	 libbsdmalloc(3LIB),   libmapmalloc(3LIB),   libmtmal‐
	   loc(3LIB), and libumem(3LIB).

   Networking Library Functions
       The functions described in this volume comprise the various  networking
       libraries.

       (3COMMPUTIL)

	   These functions constitute the communication protocol parser utili‐
	   ties library, libcommputil. This library is implemented as a shared
	   object,  libcommputil.so, but it is not automatically linked by the
	   C compilation system. Specify -lcommputil on the cc command line to
	   link with this library. See libcommputil(3LIB).

       (3DLPI)

	   These   functions  constitute  the  data  link  provider  interface
	   library, libdlpi. This library is implemented as a  shared  object,
	   libdlpi.so, but it is not automatically linked by the C compilation
	   system. Specify -ldlpi on the cc command line  to  link  with  this
	   library. See libdlpi(3LIB).

       (3DNS_SD)

	   These  functions  constitute	 the  DNS  service  discovery library,
	   libdns_sd.  This  library  is  implemented  as  a  shared   object,
	   libdns_sd.so,  but it is not automatically linked by the C compila‐
	   tion system. Specify -ldns_sd on the cc command line to  link  with
	   this library. See libdns_sd(3LIB).

       (3GSS)

	   These  functions  constitute the generic security services library.
	   This library is implemented as a shared object, libgss.so,  but  it
	   is  not  automatically  linked by the C compilation system. Specify
	   -lgss on the cc  command  line  to  link  with  this	 library.  See
	   libgss(3LIB).

       (3LDAP)

	   These  functions constitute the lightweight directory access proto‐
	   col library, libldap. This  library	is  implemented	 as  a	shared
	   object, libldap.so, but is not automatically linked by the C compi‐
	   lation system. Specify -lldap on the cc command line to  link  with
	   this library. See ldap(3LDAP).

       (3NSL)

	   These  functions  constitute	 the  network service library, libnsl.
	   This library is implemented as a shared object, libnsl.so,  but  is
	   not automatically linked by the C compilation system. Specify -lnsl
	   on the cc command line to link with this library. See libnsl(3LIB).

	   Many base networking functions are also  available  in  the	X/Open
	   networking  interfaces  library, libxnet. See section (3XNET) below
	   for more information on the libxnet interfaces.

       (3RESOLV)

	   These functions constitute the resolver  library,  libresolv.  This
	   library is implemented as a shared object, libresolv.so, but is not
	   automatically linked by the C compilation system. Specify  -lresolv
	   on  the  cc	command	 line  to  link	 with this library. See libre‐
	   solv(3LIB).

       (3RPC)

	   These functions constitute the  remote  procedure  call  libraries,
	   librpcsvc  and  librpcsoc. The latter is provided for compatibility
	   only; new applications should not link to it.  Both	libraries  are
	   implemented	as  shared  objects,  librpcsvc.so  and	 librpcsoc.so,
	   respectively. Neither library is automatically linked by the C com‐
	   pilation  system.  Specify  -lrpcsvc	 or -lrpcsoc on the cc command
	   line to link with these libraries. See librpcsvc(3LIB).

       (3SASL)

	   These functions constitute the simple authentication	 and  security
	   layer  library,  libsasl.  This  library is implemented as a shared
	   object, libsasl.so, but it is not automatically  linked  by	the  C
	   compilation	system.	 Specify -lsasl on the cc command line to link
	   with this library. See libsasl(3LIB).

       (3SIP)

	   These functions constitute the session initiation protocol library,
	   libsip.  This library is implemented as a shared object, libsip.so,
	   but it is not automatically linked by  the  C  compilation  system.
	   Specify -lsip on the cc command line to link with this library. See
	   libsip(3LIB).

       (3SLP)

	   These functions constitute the service location  protocol  library,
	   libslp.  This library is implemented as a shared object, libslp.so,
	   but it is not automatically linked by  the  C  compilation  system.
	   Specify -lslp on the cc command line to link with this library. See
	   libslp(3LIB).

       (3SOCKET)

	   These functions constitute the  sockets  library,  libsocket.  This
	   library is implemented as a shared object, libsocket.so, but is not
	   automatically linked by the C compilation system. Specify  -lsocket
	   on  the  cc	command	 line  to  link	 with  this  library. See lib‐
	   socket(3LIB).

       (3XNET)

	   These functions constitute X/Open networking interfaces which  com‐
	   ply with the X/Open CAE Specification, Networking Services, Issue 4
	   (September, 1994). This library is implemented as a shared  object,
	   libxnet.so,	but  is	 not automatically linked by the C compilation
	   system. Specify -lxnet on the cc command line  to  link  with  this
	   library.  See libxnet(3LIB) and standards(5) for compilation infor‐
	   mation.

       Under all circumstances, the use of the Sockets API is recommended over
       the  XTI	 and  TLI  APIs.  If  portability  to other XPGV4v2 (see stan‐
       dards(5)) systems is  a	requirement,  the  application	must  use  the
       libxnet	interfaces. If portability is not required, the sockets inter‐
       faces in libsocket and libnsl are recommended over  those  in  libxnet.
       Between	the  XTI  and  TLI  APIs,  the	XTI interfaces (available with
       libxnet) are recommended over the TLI interfaces (available  with  lib‐
       nsl).

   Curses Library Functions
       The functions described in this volume comprise the libraries that pro‐
       vide graphics and character screen updating capabilities.

       (3CURSES)

	   The functions constitute the following libraries:

	   libcurses

	       These functions constitute the curses library, libcurses.  This
	       library is implemented as a shared object, libcurses.so, but is
	       not automatically linked by the C compilation  system.  Specify
	       -lcurses	 on the cc command line to link with this library. See
	       libcurses(3LIB).

	   libform

	       These functions constitute the  forms  library,	libform.  This
	       library	is  implemented as a shared object, libform.so, but is
	       not automatically linked by the C compilation  system.  Specify
	       -lform  on  the	cc command line to link with this library. See
	       libform(3LIB).

	   libmenu

	       These functions constitute the  menus  library,	libmenu.  This
	       library	is  implemented as a shared object, libmenu.so, but is
	       not automatically linked by the C compilation  system.  Specify
	       -lmenu  on  the	cc command line to link with this library. See
	       libmenu(3LIB).

	   libpanel

	       These functions constitute the panels library,  libpanel.  This
	       library	is implemented as a shared object, libpanel.so, but is
	       not automatically linked by the C compilation  system.  Specify
	       -lpanel	on  the cc command line to link with this library. See
	       libpanel(3LIB).

       (3PLOT)

	   These functions constitute  the  grapnics  library,	libplot.  This
	   library  is	implemented as a shared object, libplot.so, but is not
	   automatically linked by the C compilation system. Specify -lplot on
	   the cc command line to link with this library. See libplot(3LIB).

       (3XCURSES)

	   These  functions  constitute	 the X/Open curses library, located in
	   /usr/xpg4/lib/libcurses.so. This library provides a set of interna‐
	   tionalized  functions  and  macros for creating and modifying input
	   and output to a terminal screen. Included in this library are func‐
	   tions  for  creating	 windows,  highlighting	 text,	writing to the
	   screen, reading from user input,  and  moving  the  cursor.	X/Open
	   Curses is designed to optimize screen update activities. The X/Open
	   Curses library conforms fully with Issue 4 of the  X/Open  Extended
	   Curses specification. See libcurses(3XCURSES).

   Extended Library Functions, Vol. 1
       The  functions described in this volume comprise the following special‐
       ized libraries:

       (3BSM)

	   These functions constitute the Solaris  auditing  library,  libbsm.
	   This	 library  is implemented as a shared object, libbsm.so, but is
	   not automatically linked by the C compilation system. Specify -lbsm
	   on the cc command line to link with this library. See libbsm(3LIB).

       (3CFGADM)

	   These   functions   constitute   the	 configuration	administration
	   library, libcfgadm. This library is implemented as a shared object,
	   libcfgadm.so,  but is not automatically linked by the C compilation
	   system. Specify -lcfgadm on the cc command line to link  with  this
	   library. See libcfgadm(3LIB).

       (3CONTRACT)

	   These functions constitute the contract management library, libcon‐
	   tract. This library is implemented  as  a  shared  object,  libcon‐
	   tract.so, but is not automatically linked by the C compilation sys‐
	   tem. Specify -lcontract on the cc command line to  link  with  this
	   library. See libcontract(3LIB).

       (3CPC)

	   These  functions  constitute	 the  CPU performance counter library,
	   libcpc, and the process context library, libpctx.  These  libraries
	   are	implemented  as	 shared	 objects,  libcpc.so  and  libpctx.so,
	   respectively, but are not automatically linked by the C compilation
	   system. Specify -lcpc or -lpctx on the cc command line to link with
	   these libraries. See libcpc(3LIB) and libpctx(3LIB).

       (3DAT)

	   These functions constitute the  direct  access  transport  library,
	   libdat.  This library is implemented as a shared object, libdat.so,
	   but is not automatically linked by the C compilation system.	 Spec‐
	   ify	-ldat  on  the	cc command line to link with this library. See
	   libdat(3LIB).

       (3DEVID)

	   These functions constitute the device ID  library,  libdevid.  This
	   library  is implemented as a shared object, libdevid.so, but is not
	   automatically linked by the C compilation system.  Specify  -ldevid
	   on  the  cc	command	 line  to  link	 with this library. See libde‐
	   vid(3LIB).

       (3DEVINFO)

	   These functions constitute the device information library,  libdev‐
	   info.  This	library	 is  implemented  as  a shared object, libdev‐
	   info.so, but is not automatically linked by the C compilation  sys‐
	   tem.	 Specify  -ldevinfo  on	 the cc command line to link with this
	   library. See libdevinfo(3LIB).

       (3ELF)

	   These functions constitute the ELF access library, libelf,  (Exten‐
	   sible  Linking Format). This library provides the interface for the
	   creation and analyses of "elf"  files;  executables,	 objects,  and
	   shared   objects.   libelf  is  implemented	as  a  shared  object,
	   libelf.so, but is not automatically linked  by  the	C  compilation
	   system.  Specify  -lelf  on	the  cc command line to link with this
	   library. See libelf(3LIB).

       (3EXACCT)

	   These functions constitute the extended accounting access  library,
	   libexacct,  and  the	 project  database access library, libproject.
	   These libraries are implemented as shared objects, libexacct.so and
	   libproject.so,  respectively,  but  are not automatically linked by
	   the C compilation system. Specify -lexacct or -lproject on  the  cc
	   command  line to link with these libraries. See libexacct(3LIB) and
	   libproject(3LIB).

       (3FCOE)

	   These functions constitute the Fibre	 Channel  over	Ethernet  port
	   management library. This library is implemented as a shared object,
	   libfcoe.so, but is not automatically linked by  the	C  compilation
	   system.  Specify  -lfcoe  on	 the cc command line to link with this
	   library. See libfcoe(3LIB).

       (3FM)

	   These functions constitute the  fault  management  events  library.
	   This	 library is implemented as a shared object, libfmevent.so, but
	   is not automatically linked by the C	 compilation  system.  Specify
	   -lfmevent  on  the  cc  command line to link with this library. See
	   libfmevent(3LIB).

       (3FSTYP)

	   These functions constitute  the  file  system  type	identification
	   library.  This  library  is	implemented  as a shared object, libf‐
	   styp.so, but is not automatically linked by the C compilation  sys‐
	   tem.	 Specify  -lfstyp  on  the  cc	command line to link with this
	   library. See libfstyp(3LIB).

   Extended Library Functions, Vol. 2
       The functions described in this volume comprise the following  special‐
       ized libraries:

       (3GEN)

	   These functions constitute the string pattern-matching and pathname
	   manipulation library, libgen. This  library	is  implemented	 as  a
	   shared  object, libgen.so, but is not automatically linked by the C
	   compilation system. Specify -lgen on the cc command	line  to  link
	   with this library. See libgen(3LIB).

       (3HBAAPI)

	   These functions constitute the common fibre channel HBA information
	   library, libhbaapi. This library is implemented as a shared object,
	   libhbaapi.so,  but is not automatically linked by the C compilation
	   system. Specify -lhbaapi on the cc command line to link  with  this
	   library. See libhbaapi(3LIB).

       (3ISCSIT)

	   These functions constitute the iSCSI Management library, libiscsit.
	   This library is implemented as a shared object,  libiscsit.so,  but
	   is  not  automatically  linked by the C compilation system. Specify
	   -liscsit on the cc command line to  link  with  this	 library.  See
	   libiscsit(3LIB).

       (3KSTAT)

	   These  functions constitute the kernel statistics library, which is
	   implemented as a shared object, libkstat.so, but is	not  automati‐
	   cally linked by the C compilation system. Specify -lkstat on the cc
	   command line to link with this library. See libkstat(3LIB).

       (3KVM)

	   These  functions  allow  access  to	the  kernel's  virtual	memory
	   library, which is implemented as a shared object, libkvm.so, but is
	   not automatically linked by the C compilation system. Specify -lkvm
	   on the cc command line to link with this library. See libkvm(3LIB).

       (3LAYOUT)

	   These  functions  constitute	 the  layout service library, which is
	   implemented as a shared object, liblayout.so, but is not  automati‐
	   cally  linked  by the C compilation system. Specify -llayout on the
	   cc command line to link with this library. See liblayout(3LIB).

       (3LGRP)

	   These functions constitute the locality  group  library,  which  is
	   implemented	as  a  shared object, liblgrp.so, but is not automati‐
	   cally linked by the C compilation system. Specify -llgrp on the  cc
	   command line to link with this library. See liblgrp(3LIB).

       (3M)

	   These  functions  constitute	 the  mathematical library, libm. This
	   library is implemented as a shared  object,	libm.so,  but  is  not
	   automatically  linked  by  the C compilation system. Specify -lm on
	   the cc command line to link with this library. See libm(3LIB).

       (3MAIL)

	   These functions constitute the  user	 mailbox  management  library,
	   libmail.  This  library  is	implemented  as	 a shared object, lib‐
	   mail.so, but is not automatically linked by the C compilation  sys‐
	   tem.	 Specify  -lmail  on  the  cc  command	line to link with this
	   library. See libmail(3LIB).

       (3MP)

	   These functions constitute the integer mathematical library, libmp.
	   This	 library  is  implemented as a shared object, libmp.so, but is
	   not automatically linked by the C compilation system. Specify  -lmp
	   on the cc command line to link with this library. See libmp(3LIB).

       (3MPAPI)

	   These   functions   constitute  the	Common	Mulitipath  Management
	   library, libMPAPI. This library is implemented as a shared  object,
	   libMPAPI.so,	 but  is not automatically linked by the C compilation
	   system. Specify -lMPAPI on the cc command line to  link  with  this
	   library. See libMPAPI(3LIB).

       (3MVEC)

	   These  functions  constitute	 the vector mathematical library, lib‐
	   mvec. This library is implemented as a shared  object,  libmvec.so,
	   but	is not automatically linked by the C compilation system. Spec‐
	   ify -lmvec on the cc command line to link with  this	 library.  See
	   libmvec(3LIB).

   Extended Library Functions, Vol. 3
       The  functions described in this volume comprise the following special‐
       ized libraries:

       (3NVPAIR)

	   These functions constitute the name-value pair library,  libnvpair.
	   This	 library  is implemented as a shared object, libnvpair.so, but
	   is not automatically linked by the C	 compilation  system.  Specify
	   -lnvpair on the cc command line to link with this library. See lib‐
	   nvpair(3LIB).

       (3PAM)

	   These functions  constitute	the  pluggable	uuthentication	module
	   library,  libpam.  This  library is implemented as a shared object,
	   libpam.so, but is not automatically linked  by  the	C  compilation
	   system.  Specify  -lpam  on	the  cc command line to link with this
	   library. See libpam(3LIB).

       (3PAPI)

	   These functions constitute the Free Standards Group	Open  Printing
	   API	(PAPI)	library,  libpapi.  This  library  is implemented as a
	   shared object, libpapi.so, but is not automatically linked by the C
	   compilation	system.	 Specify -lpapi on the cc command line to link
	   with this library. See libpapi(3LIB).

       (3PICL)

	   These functions constitute the PICL library, libpicl. This  library
	   is implemented as a shared object, libpicl.so, but is not automati‐
	   cally linked by the C compilation system. Specify -lpicl on the  cc
	   command  line  to  link  with  this	library. See libpicl(3LIB) and
	   libpicl(3PICL).

       (3PICLTREE)

	   These functions constitute the PICL plug-in	library,  libpicltree.
	   This library is implemented as a shared object, libpicltree.so, but
	   is not automatically linked by the C	 compilation  system.  Specify
	   -lpicltree  on  the	cc command line to link with this library. See
	   libpicltree(3LIB) and libpicltree(3PICLTREE).

       (3POOL)

	   These functions  constitute	the  pool  configuration  manipulation
	   library,  libpool.  This library is implemented as a shared object,
	   libpool.so, but is not automatically linked by  the	C  compilation
	   system.  Specify  -lpool  on	 the cc command line to link with this
	   library. See libpool(3LIB).

       (3PROJECT)

	   These functions constitute the  project  database  access  library,
	   libproject. This library is implemented as a shared object, libpro‐
	   ject.so, but is not automatically linked by the C compilation  sys‐
	   tem.	 Specify  -lproject  on	 the cc command line to link with this
	   library. See libproject(3LIB).

       (3REPARSE)

	   These functions constitute the reparse point	 library,  libreparse.
	   This	 library is implemented as a shared object, libreparse.so, but
	   is not automatically linked by the C	 compilation  system.  Specify
	   -lreparse  on  the  cc  command line to link with this library. See
	   libreparse(3LIB).

       (3RSM)

	   These  functions  constitute	 the  remote  shared  memory  library,
	   librsm.  This library is implemented as a shared object, librsm.so,
	   but is not automatically linked by the C compilation system.	 Spec‐
	   ify	-lrsm  on  the	cc command line to link with this library. See
	   librsm(3LIB).

   Extended Library Functions, Vol. 4
       The functions described in this volume comprise the following  special‐
       ized libraries:

       (3SCF)

	   These  functions  constitute	 the  object-caching memory allocation
	   library, libscf. This library is implemented as  a  shared  object,
	   libscf.so,  but  is	not  automatically linked by the C compilation
	   system. Specify -lscf on the cc command  line  to  link  with  this
	   library. See libscf(3LIB).

       (3SEC)

	   These functions constitute the file access control library, libsec.
	   This library is implemented as a shared object, libsec.so,  but  is
	   not automatically linked by the C compilation system. Specify -lsec
	   on the cc command line to link with this library. See libsec(3LIB).

       (3SECDB)

	   These  functions  constitute	 the  security	 attributes   database
	   library,  libsecdb. This library is implemented as a shared object,
	   libsecdb.so, but is not automatically linked by the	C  compilation
	   system.  Specify  -lsecdb  on the cc command line to link with this
	   library. See libsecdb(3LIB).

       (3SNMP)

	   These functions constitute the SNMP libraries, libssagent and  lib‐
	   ssasnmp.  These  libraries  are implemented as shared objects, lib‐
	   ssagent.so and libssasnmp.so, respectively, but are	not  automati‐
	   cally  linked  by  the  C  compilation system. Specify -lssagent or
	   -lssasnmp on the cc command line to link with these libraries.  See
	   libssagent(3LIB) and libssasnmp(3LIB).

       (3STMF)

	   These  functions constitute the SCSI Target Mode Framework library,
	   libstmf. This library is  implemented  as  a	 shared	 object,  lib‐
	   stmf.so,  but is not automatically linked by the C compilation sys‐
	   tem. Specify -lstmf on the  cc  command  line  to  link  with  this
	   library. See libstmf(3LIB).

       (3SYSEVENT)

	   These  functions  constitute the system event library, libsysevent.
	   This library is implemented as a shared object, libsysevent.so, but
	   is  not  automatically  linked by the C compilation system. Specify
	   -lsysevent on the cc command line to link with  this	 library.  See
	   libsysevent(3LIB).

       (3TECLA)

	   These  functions  constitute	 the  interactive  command-line	 input
	   library, libtecla. This library is implemented as a shared  object,
	   libtecla.so,	 but  is not automatically linked by the C compilation
	   system. Specify -ltecla on the cc command line to  link  with  this
	   library. See libtecla(3LIB).

       (3TNF)

	   These  functions  constitute	 the TNF libraries, libtnf, libtnfctl,
	   and libtnfprobe. These libraries are implemented as shared objects,
	   libtnf.so,  libtnfctl.so, and libtnfprobe.so, respectively, but are
	   not automatically linked  by	 the  C	 compilation  system.  Specify
	   -ltnf,  -ltnfctl, or -ltnfprobe on the cc command line to link with
	   these libraries. See libtnfctl(3TNF) and libtnfctl(3LIB).

       (3TSOL)

	   These functions constitute the Trusted Extensions library, libtsol,
	   and	 the  Trusted  Extensions  network  library,  libtsnet.	 These
	   libraries are implemented as shared objects, libtsol.so  and	 libt‐
	   snet.so, but are not automatically linked by the C compilation sys‐
	   tem. Specify -ltsol or -ltsnet on the cc command line to link  with
	   these libraries. See libtsol(3LIB) and libtsnet(3LIB).

       (3UUID)

	   These   functions  constitute  the  universally  unique  identifier
	   library, libuuid. This library is implemented as a  shared  object,
	   libuuid.so,	but  is	 not automatically linked by the C compilation
	   system. Specify -luuid on the cc command line  to  link  with  this
	   library. See libuuid(3LIB).

       (3VOLMGT)

	   These  functions  constitute	 the  volume  management library, lib‐
	   volmgt. This library	 is  implemented  as  a	 shared	 object,  lib‐
	   volmgt.so,  but  is	not  automatically linked by the C compilation
	   system. Specify -lvolmgt on the cc command line to link  with  this
	   library. See libvolmgt(3LIB).

       (3WSREG)

	   These  functions  constitute	 the product install registry library,
	   libwsreg. This library is implemented as a  shared  object,	libws‐
	   reg.so,  but	 is not automatically linked by the C compilation sys‐
	   tem. Specify -lwsreg on the cc  command  line  to  link  with  this
	   library. See libwsreg(3LIB).

       (3XTSOL)

	   These  functions constitute the Trusted Extensions to the X windows
	   library, libXtsol. This library is implemented as a shared  object,
	   libXtsol.so,	 but  is not automatically linked by the C compilation
	   system. Specify -lX11 and then -lXtsol on the cc  command  line  to
	   link with this library. See libXtsol(3LIB).

   Multimedia Library Functions
       (3MLIB)

	   These  functions  constitute	 the  mediaLib	library, libmlib. This
	   library is implemented as a shared object, libmlib.so, but  is  not
	   automatically linked by the C compilation system. Specify -lmlib on
	   the cc command line to link with this library. See libmlib(3LIB).

       (3MMS)

	   These functions constitute the  Media  Management  System  library,
	   libmms.  This library is implemented as a shared object, libmms.so,
	   but is not automatically linked by the C compilation system.	 Spec‐
	   ify	-lmms  on  the	cc command line to link with this library. See
	   libmms(3LIB).

DEFINITIONS
       A character is any bit pattern able to fit into a byte on the  machine.
       In  some	 international languages, however, a "character" might require
       more than one byte, and is represented in multi-bytes.

       The null character is a character with value 0,	conventionally	repre‐
       sented  in  the	C  language  as \0. A character array is a sequence of
       characters. A null-terminated character array (a string) is a  sequence
       of characters, the last of which is the null character. The null string
       is a character array containing only the terminating null character.  A
       null pointer is the value that is obtained by casting 0 into a pointer.
       C guarantees that this value will not  match  that  of  any  legitimate
       pointer, so many functions that return pointers return NULL to indicate
       an error. The macro NULL is defined in <stdio.h>.  Types	 of  the  form
       size_t are defined in the appropriate headers.

MULTITHREADED APPLICATIONS
       Both  POSIX  threads  and  Solaris  threads can be used within the same
       application. Their implementations are completely compatible with  each
       other;  however,	 only  POSIX  threads  guarantee  portability to other
       POSIX-conforming environments.

       The libpthread(3LIB) and libthread(3LIB) libraries are  implemented  as
       filters on libc(3LIB).

       When  compiling	a  multithreaded  application,	the -mt option must be
       specified on the command line.

       There is no need for a multithreaded application to link with -lthread.
       An  application	must link with -lpthread only when POSIX semantics for
       fork(2) are desired. When an application is linked  with	 -lpthread,  a
       call  to	 fork()	 assumes the behavior fork1(2) rather than the default
       behavior that forks all threads.

       When   compiling	  a   POSIX-conforming	 application,	 either	   the
       _POSIX_C_SOURCE or _POSIX_PTHREAD_SEMANTICS option must be specified on
       the command line.  For  POSIX.1c-conforming  applications,  define  the
       _POSIX_C_SOURCE flag to be >= 199506L:

	 cc -mt [ flag... ] file... -D_POSIX_C_SOURCE=199506L -lpthread

       For  POSIX  behavior  with  the Solaris fork() and fork1() distinction,
       compile as follows:

	 cc -mt [ flag... ] file... -D_POSIX_PTHREAD_SEMANTICS

       For Solaris threads behavior, compile as follows:

	 cc -mt [ flag... ] file...

       Unsafe interfaces should be called only from the main thread to	ensure
       the application's safety.

       MT-Safe	interfaces  are denoted in the ATTRIBUTES section of the func‐
       tions and libraries manual pages (see attributes(5)). If a manual  page
       does not state explicitly that an interface is MT-Safe, the user should
       assume that the interface is unsafe.

REALTIME APPLICATIONS
       The environment variable LD_BIND_NOW must be set to a non-null value to
       enable  early  binding.	Refer  to the "When Relocations are Processed"
       chapter in Linker and Libraries Guide for additional information.

FILES
       INCDIR	      usually /usr/include

       LIBDIR	      usually either  /lib  or	/usr/lib  (32-bit)  or	either
		      /lib/64 or /usr/lib/64 (64-bit)

       LIBDIR/*.so    shared libraries

ACKNOWLEDGMENTS
       Sun  Microsystems, Inc. gratefully acknowledges The Open Group for per‐
       mission to reproduce portions of its copyrighted documentation.	Origi‐
       nal  documentation  from	 The  Open  Group  can	be  obtained online at
       http://www.opengroup.org/bookstore/.

       The Institute of Electrical and	Electronics  Engineers	and  The  Open
       Group, have given us permission to reprint portions of their documenta‐
       tion.

       In the following statement, the phrase ``this text'' refers to portions
       of the system documentation.

       Portions	 of  this text are reprinted and reproduced in electronic form
       in the SunOS Reference Manual, from  IEEE  Std  1003.1,	2004  Edition,
       Standard for Information Technology -- Portable Operating System Inter‐
       face (POSIX), The Open Group Base Specifications Issue 6, Copyright (C)
       2001-2004 by the Institute of Electrical and Electronics Engineers, Inc
       and The Open Group.  In the event of any discrepancy between these ver‐
       sions  and  the original IEEE and The Open Group Standard, the original
       IEEE and The Open Group Standard is the referee document.  The original
       Standard	    can	    be	  obtained    online	at    http://www.open‐
       group.org/unix/online.html.

       This notice shall appear on any product containing this material.

SEE ALSO
       ar(1), ld(1), fork(2), stdio(3C), attributes(5), standards(5)

       Linker and Libraries Guide

       Performance Profiling Tools

       ANSI C Programmer's Guide

DIAGNOSTICS
       For functions that return floating-point values, error handling	varies
       according  to  compilation  mode. Under the -Xt (default) option to cc,
       these functions return the conventional values 0, ±HUGE,	 or  NaN  when
       the  function is undefined for the given arguments or when the value is
       not representable. In the -Xa and -Xc compilation modes,	 ±HUGE_VAL  is
       returned	 instead of ±HUGE. (HUGE_VAL and HUGE are defined in math.h to
       be infinity and the largest-magnitude single-precision number,  respec‐
       tively.)

NOTES
       None  of	 the  functions, external variables, or macros should be rede‐
       fined in the user's programs. Any other name can be  redefined  without
       affecting  the  behavior of other library functions, but such redefini‐
       tion might conflict with a declaration in an included header.

       The headers in INCDIR provide function  prototypes  (function  declara‐
       tions  including	 the  types  of	 arguments)  for most of the functions
       listed in this manual. Function prototypes allow the compiler to	 check
       for  correct  usage  of these functions in the user's program. The lint
       program checker can also be used and will report discrepancies even  if
       the  headers are not included with #include statements. Definitions for
       Sections 2 and 3C are checked automatically. Other definitions  can  be
       included	 by  using  the	 -l option to lint. (For example, -lm includes
       definitions for libm.) Use of lint is highly recommended. See the  lint
       chapter in Performance Profiling Tools

       Users  should carefully note the difference between STREAMS and stream.
       STREAMS is a set of kernel mechanisms that support the  development  of
       network	services  and  data  communication  drivers. It is composed of
       utility routines, kernel facilities, and a set of  data	structures.  A
       stream  is a file with its associated buffering. It is declared to be a
       pointer to a type FILE defined in <stdio.h>.

       In detailed definitions of components, it  is  sometimes	 necessary  to
       refer to symbolic names that are implementation-specific, but which are
       not necessarily expected to be accessible to  an	 application  program.
       Many  of	 these	symbolic names describe boundary conditions and system
       limits.

       In this section, for readability, these implementation-specific	values
       are  given  symbolic names. These names always appear enclosed in curly
       brackets to distinguish them from symbolic names of  other  implementa‐
       tion-specific  constants that are accessible to application programs by
       headers. These names are not necessarily accessible to  an  application
       program	through a header, although they can be defined in the documen‐
       tation for a particular system.

       In general, a portable application program should not  refer  to	 these
       symbolic	 names	in its code. For example, an application program would
       not be expected to test the length of an argument list given to a  rou‐
       tine to determine if it was greater than {ARG_MAX}.

SunOS 5.11			  7 Oct 2009			      Intro(3)
[top]

List of man pages available for OpenIndiana

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net