pdf to image converter using c# : Add signature field to pdf software SDK project winforms windows azure UWP 201212-ug-php-oracle-188476028-part394

Using DRCP in PHP
DRCP Option
Description
maxconn_cbrok
The maximum number of connections that each connection 
broker can handle. Set the per-process file descriptor limit of the 
operating system sufficiently high so that it supports the 
number of connections specified. The default is 40000. Note: 
this can only be set with alter_param(). 
The parameters have been described here relative to their use in PHP but it is worth 
remembering that the DRCP pool is usable concurrently by other programs, including those 
using Perl's DBD::Oracle and Python's cx_Oracle extensions. 
In general, if pool parameters are changed, the pool should be restarted, otherwise server 
processes will continue to use old settings.
The inactivity_timeout setting terminates idle pooled servers, helping optimize database 
resources. To avoid pooled servers permanently being held onto by a dead web server process 
or a selfish PHP script, the max_think_time parameter can be set. The parameters num_cbrok 
and maxconn_cbrok can be used to distribute the persistent connections from the clients 
across multiple brokers. This may be needed in cases where the operating system per-process 
descriptor limit is small.
Some customers have found that having several connection brokers improves 
performance.
The max_use_session
and max_lifetime_session
parameters help protect against any 
unforeseen problems affecting server processes. The default values will be suitable for most 
users.
Users of Oracle Database 11.1.0.6 must apply the database patch for bug 6474441 to 
avoid query errors. It also enables LOGON trigger support. This patch is not needed with 11.2 
or 11.1.0.7 onwards.
Configuring PHP for DRCP
PHP must be built with the OCI8 1.3 or later extension. (PHP 5.3 contains OCI8 1.4).
DRCP functionality is only available when PHP OCI8 is linked with Oracle Database 11g 
client libraries and connected to Oracle Database 11g.
Before using DRCP, the new php.ini parameter oci8.connection_class should be set to 
specify the connection class used by all the requests for pooled servers by the PHP 
application.
oci8.connection_class = MYPHPAPP
The parameter can be set in php.ini, .htaccess or httpd.conf
files. It can also be set and 
retrieved programmatically using the PHP functions ini_set() and ini_get().
The OCI8 extension has several legacy php.ini configuration parameters for tuning 
persistent connections. These were mainly used to limit idle resource usage. With DRCP, the 
parameters still have an effect but it may be easier to use the DRCP pool configuration 
options.
267
Add signature field to pdf - C# PDF Field Edit Library: insert, delete, update pdf form field in C#.net, ASP.NET, MVC, Ajax, WPF
Online C# Tutorial to Insert, Delete and Update Fields in PDF Document
add fillable fields to pdf; change font size in fillable pdf form
Add signature field to pdf - VB.NET PDF Field Edit library: insert, delete, update pdf form field in vb.net, ASP.NET, MVC, Ajax, WPF
How to Insert, Delete and Update Fields in PDF Document with VB.NET Demo Code
cannot save pdf form in reader; create a fillable pdf form online
PHP Connection Pooling and High Availability
Table 14: Existing php.ini parameters for persistent connections.
php.ini Parameter
Behavior with DRCP
oci8.persistent_timeout
At the timeout of an idle PHP connection, PHP will close 
the Oracle connection to the broker. The default is no 
timeout.
oci8.max_persistent
The maximum number of unique persistent connections 
that each PHP process will maintain to the broker. When 
the limit is reached a new persistent connection behaves 
like oci_connect() and releases the connection at the 
end of the script. The default is no limit. Note: The DRCP 
maxsize setting will still be enforced by the database 
independently from oci8.max_persistent.
oci8.ping_interval
The oci8.ping_interval
value 
is also used for non-
persistent connections when DRCP is used. The default 
is 60 seconds.
With oci8.ping_interval
the non-DRCP recommendation to set it to -1 to disable pinging, and 
to use appropriate error checking still holds true with DRCP. Also, the use of FAN (see later) 
reduces the chance of idle connections becoming unusable. 
Web servers and the network should benefit from oci8.statement_cache_size being set. For 
best performance it should generally be larger than the size of the working set of SQL 
statements. To tune it, monitor general web server load and the AWR “bytes sent via 
SQL*Net to client“ values. The latter statistic should benefit from not needing to send 
statement meta-data to PHP. Adjust the statement cache size to your satisfaction.
Once you are happy with the statement cache size, then tune the DRCP pool 
session_cached_cursors value. Monitor AWR reports with the goal to make the “session 
cursor cache hits“ close to the number of soft parses. Soft parses can be calculated from 
“parse count (total)“ minus “parse count (hard)”.
Application Deployment for DRCP
PHP applications must specify the server type POOLED in the connect string. Using Oracle’s 
Easy Connect syntax, the PHP call to connect to the sales database on myhost would look like:
$c = oci_pconnect('myuser', 'mypassword', 'myhost/sales:POOLED');
Or if PHP uses an Oracle Network connect name that looks like:
$c = oci_pconnect('myuser', 'mypassword', 'salespool');
Then only the Oracle Network configuration file tnsnames.ora
needs to be modified:
salespool=(DESCRIPTION=(ADDRESS=(PROTOCOL=tcp)
(HOST=myhost.dom.com)
(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=sales)
(SERVER=POOLED)))
If these changes are made and the database is not actually configured for DRCP, or the pool is 
not started, then connections will not succeed and an error will be returned to PHP.
268
C# PDF Digital Signature Library: add, remove, update PDF digital
things. Add a signature or an empty signature field in any PDF file page. Search unsigned signature field in PDF document. Prepare
add photo to pdf form; cannot save pdf form
VB.NET PDF Digital Signature Library: add, remove, update PDF
things. Add a signature or an empty signature field in any PDF file page. Search unsigned signature field in PDF document. Prepare
convert word doc to pdf with editable fields; acrobat create pdf form
Using DRCP in PHP
Although applications can choose whether or not to use pooled connections at runtime, 
care must be taken to the configure the database appropriately for the number of expected 
connections, and also to stop inadvertent use of non-pooled connections leading to a resource 
shortage.
Closing Connections
PHP scripts that do not currently use oci_close()
should be examined to see if they can use it 
to explicitly return connections to the pool, allowing maximum use of pooled servers:
// 1. Do some database operations
$c = oci_pconnect('myuser', 'mypassword', 'myhost/sales:POOLED');
. . .
oci_commit($c);
oci_close($c); // Release the connection to the DRCP pool
// 2. Do lots of non-database work
. . .
// 3. Do some more database operations
$c = oci_pconnect('myuser', 'mypassword', 'myhost/sales:POOLED');
. . . 
oci_commit($c);
oci_close($c);
Remember to free statement and other resources that internally increase the reference count 
on the PHP connection and will otherwise stop a database connection from closing.
Prior to OCI8 1.3, closing oci_connect() and oci_new_connect() connections had an effect 
but closing an oci_pconnect() connection was a no-op. From OCI8 1.3, oci_close() on a 
persistent connection rolls back any uncommitted transaction. Also the extension will do a roll 
back when all PHP variables referencing a persistent connection go out of scope, for example 
if the connection was opened in a function and the function has now finished. For DRCP, in 
addition to the rollback, the connection is also released; a subsequent oci_pconnect() may 
get a different connection. For DRCP, the benefit is that scripts taking advantage of persistent 
connections can explicitly return a server to the pool when non-database processing occurs, 
allowing other concurrent scripts to make use of the pooled server.
With pooled servers, the recommendation is to release the connection when the script 
does a significant amount of processing that is not database related. Explicitly control 
commits and rollbacks so there is no unexpectedly open transaction when the close or end-of-
scope occurs. Scripts coded like this can use oci_close() to take advantage of DRCP but still 
be portable to older versions of the OCI8 extension.
If behavior where oci_close() is a no-op for all connection types is preferred, set the 
php.ini parameter oci8.old_oci_close_semantics to On.
Transactions Across Re-connection
Scripts should avoid re-opening connections if there are incomplete transactions:
// 1. Do some database operations
$c = oci_pconnect('myuser', 'mypassword', 'salespool');
// Start a transaction
$s = oci_parse($c, 'insert into mytab values (1)');
269
C# PDF insert image Library: insert images into PDF in C#.net, ASP
into PDF form field. Access to freeware download and online C#.NET class source code. How to insert and add image, picture, digital photo, scanned signature or
add signature field to pdf; add fields to pdf
VB.NET PDF insert image library: insert images into PDF in vb.net
Import graphic picture, digital photo, signature and logo into PDF Add images to any selected PDF page in VB.NET. Insert images into PDF form field in VB.NET.
change font pdf fillable form; pdf form change font size
PHP Connection Pooling and High Availability
$r = oci_execute($s, OCI_NO_AUTO_COMMIT); // no commit
...
// BAD: no commit or rollback done
// 2. Continue database operations on same credentials
$c = oci_pconnect('myuser', 'mypassword', 'salespool');
$s = oci_parse($c, 'insert into mytab values (2)');
$r = oci_execute($s, OCI_NO_AUTO_COMMIT); // no commit
// Intend to commit both 1 & 2 but behavior could be random
oci_commit($c);
If there was a node or network failure just prior to point 2, the first transaction could be lost. 
The second connection command may return a new, valid connection if a ping (see 
oci8.ping_interval) occurs to validate the connection, and the script might not be aware that 
only the second part of the transaction is committed.
The script should do an explicit commit or rollback before the second connect, or simply 
continue to use the original connection. It should always do appropriate error handling.
LOGON and LOGOFF Triggers with DRCP
LOGON triggers are useful for setting session attributes needed by each PHP connection. For 
example a trigger could be used to execute an ALTER SESSION statement to set a date format. 
The LOGON trigger will execute when oci_pconnect() first creates the session, and the 
session will be reused by subsequent persistent connections. Scripts save time by no longer 
always executing code to set the date format.
The suggested practice with DRCP is to use LOGON triggers only for setting session 
attributes and not for executing per PHP-connection logic such as custom logon auditing. This 
recommendation is also true for persistent connections with dedicated or shared servers.
Database actions that must be performed exactly once per OCI8 connection call should be 
explicitly executed in the PHP script.
From Oracle 11gR2 onwards, LOGOFF triggers fire for pooled servers when sessions are 
terminated. For oci_connect() and oci_new_connect() connections, this is with oci_close() 
or at the end of the script. For oci_pconnect() connections, it can happen when the pooled 
server process naturally terminates or its session needs to be recreated.
It is not possible to depend on triggers for tracking PHP OCI8 connect calls. The caching, 
pooling, timing out and recreation of sessions and connections with or without DRCP can 
distort any record. With pooled servers, LOGON triggers can fire at authentication and when 
the session is created, in effect firing twice for the initial connection.
Changing Passwords with DRCP Connections
In general, PHP applications that change passwords should avoid using oci_pconnect(). This 
call will use the old password to match an open connection in PHP’s persistent connection 
cache without requiring re- authentication to the database with the new password. This can 
cause confusion over which password to connect with since if there is no cached connection it 
is the new password that must be used. With DRCP, there is a further limitation - connections 
cannot be used to change passwords programmatically. PHP scripts that use 
oci_password_change() should continue to use dedicated or shared servers. 
270
How to C#: Basic SDK Concept of XDoc.PDF for .NET
You may add PDF document protection functionality into your C# program. To be specific, you can edit PDF password and digital signature, and set PDF file
add date to pdf form; pdf form save
VB.NET PDF: Basic SDK Concept of XDoc.PDF
You may add PDF document protection functionality into your VB.NET program. To be specific, you can edit PDF password and digital signature, and set PDF file
android edit pdf forms; adding a signature to a pdf form
Monitoring DRCP
Monitoring DRCP
Data dictionary views are available to monitor the performance of DRCP. Database 
administrators can check statistics such as the number of busy and free servers, and the 
number of hits and misses in the pool against the total number of requests from clients. The 
views are:
DBA_CPOOL_INFO
V$PROCESS
V$SESSION
V$CPOOL_STATS
V$CPOOL_CC_STATS
V$CPOOL_CONN_INFO
For Oracle RAC, there are GV$CPOOL_STATS, GV$CPOOL_CC_STATS and 
GV$CPOOL_CONN_INFO views corresponding to the instance-level views. These record DRCP 
statistics across clustered instances. If a database instance in a cluster is shut down, the 
statistics for that instance are purged from the GV$
views.
The DRCP statistics are reset each time the pool is started.
DBA_CPOOL_INFO View
DBA_CPOOL_INFO displays configuration information about the DRCP pool. The columns are 
equivalent to the dbms_connection_pool.configure_pool() settings described in the table of 
DRCP configuration options, with the addition of a STATUS column. The status is ACTIVE
if the 
pool has been started and INACTIVE otherwise. Note the pool name column is called 
CONNECTION_POOL. This example checks whether the pool has been started and finds the 
maximum number of pooled servers:
SQL> select connection_pool, status, maxsize
from dba_cpool_info;
CONNECTION_POOL              STATUS              MAXSIZE
---------------------------- ---------------- ----------
SYS_DEFAULT_CONNECTION_POOL  ACTIVE                   40
In Oracle 11gR2, DBA_CPOOL_INFO gained NUM_CBROK and MAXCONN_CBROK columns, 
equivalent to the pool configuration options of the same names. In Oracle 11gR1 the number 
of configured brokers per instance can be found from the V$PROCESS view, for example on 
Linux this query shows one broker has been enabled:
SQL> select program
from v$process
where program like 'oracle%(N%)';
PROGRAM
------------------------------------------------
oracle@localhost (N001)
271
VB.NET PDF Library SDK to view, edit, convert, process PDF file
NET program. Password, digital signature and PDF text, image and page redaction will be used and customized. PDF Annotation Edit.
adding form fields to pdf files; adding text fields to pdf
C# Create PDF Library SDK to convert PDF from other file formats
can add some additional information to generated PDF file. What's more, you can also protect created PDF file by adding digital signature (watermark) on PDF
convert word document to editable pdf form; change font size pdf form reader
PHP Connection Pooling and High Availability
V$PROCESS and V$SESSION Views
The V$SESSION view will show information about the currently active DRCP sessions. It can 
also be joined with V$PROCESS via V$SESSION.PADDR = V$PROCESS.ADDR to correlate the 
views.
V$CPOOL_STATS View
V$CPOOL_STATS
displays information about the DRCP statistics for an instance.
Table 15: V$CPOOL_STATS View.
Column
Description
POOL_NAME
Name of the Database Resident Connection Pool.
NUM_OPEN_SERVERS
Total number of busy and free servers in the pool (including 
the authentication servers).
NUM_BUSY_SERVERS
Total number of busy servers in the pool (not including the 
authentication servers).
NUM_AUTH_SERVERS
Number of authentication servers in the pool.
NUM_REQUESTS
Number of client requests.
NUM_HITS
Total number of times client requests found matching 
pooled servers and sessions in the pool.
NUM_MISSES
Total number of times client requests could not find a 
matching pooled server and session in the pool.
NUM_WAITS
Total number of client requests that had to wait due to non-
availability of free pooled servers.
WAIT_TIME
Reserved for future use.
CLIENT_REQ_TIMEOUTS
Reserved for future use.
NUM_AUTHENTICATIONS
Total number of authentications of clients done by the pool.
NUM_PURGED
Total number of sessions purged by the pool.
HISTORIC_MAX
Maximum size that the pool has ever reached. With PHP 
this is likely to reach the maximum pool size value.
The V$CPOOL_STATS view can be used to assess how efficient the pool settings are. This 
example query shows an application using the pool effectively. The low number of misses 
indicates that servers and sessions were reused. The wait count shows just over 1% of 
requests had to wait for a pooled server to become available:
SQL> select num_requests,num_hits,num_misses,num_waits
from v$cpool_stats;
NUM_REQUESTS   NUM_HITS NUM_MISSES  NUM_WAITS
------------ ---------- ---------- ----------
100031      99993         38       1054
272
C# PDF Convert to Images SDK: Convert PDF to png, gif images in C#
image files including all PDF contents, like watermark and signature in .NET. C#.NET DLLs Solution for Converting Images to PDF in C# Add necessary references:
adding text fields to a pdf; create a pdf form from excel
C# PDF remove image library: remove, delete images from PDF in C#.
Auto Fill-in Field Data. Field: Insert, Delete, Update Field. vector image, graphic picture, digital photo, scanned signature, logo, etc. Add necessary references
pdf fillable form creator; adding images to pdf forms
Monitoring DRCP
If oci8.connection_class is set (allowing pooled servers and sessions to be reused) then 
NUM_MISSES is low. If the pool maxsize is too small for the connection load then NUM_WAITS 
is high:
NUM_REQUESTS   NUM_HITS NUM_MISSES  NUM_WAITS
------------ ---------- ---------- ----------
50352      50348          4      50149
Tune the pool size by monitoring the NUM_WAITS trend. If the value is high then increase the 
number of pooled servers.
If the connection class is left unset, the sharing of pooled servers is restricted to within 
each web server process. Even if the pool size is large, session sharing is limited causing poor 
utilization of pooled servers and contention for them:
NUM_REQUESTS   NUM_HITS NUM_MISSES  NUM_WAITS
------------ ---------- ---------- ----------
64152      17941      46211      15118
If NUM_HITS is 0 or very low, one potential cause is the use of oci_connect() since this is 
designed to recreate the session each time it is called. Use oci_pconnect() instead.
V$CPOOL_CC_STATS View
V$CPOOL_CC_STATS
displays information about the connection class level statistics for the 
pool per instance. The columns are similar to those of V$CPOOL_STATS described in Table 15, 
with a CCLASS_NAME
column giving the name of the connection sub-pool the results are for:
SQL> select cclass_name, num_requests, num_hits, num_misses
from v$cpool_cc_stats;
CCLASS_NAME                      NUM_REQUESTS   NUM_HITS NUM_MISSES
-------------------------------- ------------ ---------- ----------
HR.MYPHPAPP                           100031      99993         38
SCOTT.SHARED                              10          0         10
CJ.OCI:SP:wshbIFDtb7rgQwMyuYvodA           1          0          1
For PHP, the CCLASS_NAME
value is composed of the value of the username and of the 
oci8.connection_class value used by the connecting PHP processes. The example above 
shows an application known as MYPHPAPP using the pool effectively.
For programs like SQL*Plus that were not built using Oracle’s Session Pooling APIs, the 
class name will be SHARED. The example shows that ten such connections were made as the 
user SCOTT. Although these programs share the same connection class, new sessions are 
created for each connection, keeping each cleanly isolated from any unwanted session 
changes. This is similar to using PHP’s oci_connect() with DRCP pooled servers.
The last line of the example output shows a system generated class name for an 
application that created a connection without explicitly setting oci8.connection_class, or had it 
set to an empty string. Pooling would not be effectively used if this application continued to 
be executed. Such an entry could be an indication that a php.ini file is mis-configured.
273
PHP Connection Pooling and High Availability
V$CPOOL_CONN_INFO View
This view gives insight into client processes that are connected to the connection broker, 
making it easier to monitor and trace applications that are currently using pooled servers or 
are idle.
This view was introduced in Oracle 11gR2.
Table 16: V$CPOOL_CONN_INFO View.
Column
Description
CMON_ADDR
Address of the connection broker
SESSION_ADDR
Address of the session associated with the 
connection. NULL if there is no active 
session. Can be joined with 
V$SESSION.SADDR
CONNECTION_ADDR
Address of the connection
USERNAME
Name of the user associated with the 
connection
PROXY_USER
Name of the proxy user
CCLASS_NAME
Connection class associated with the 
connection
PURITY
Will be SELF for oci_pconnect() calls or 
NEW otherwise
TAG
Not set by PHP
SERVICE
TNS service name for the connection
PROCESS_ID
Process ID of the PHP or Apache process
PROGRAM
Program name of the PHP or Apache process
MACHINE
Machine name where PHP is running
TERMINAL
Terminal identifier of the PHP process that 
created the connection
CONNECTION_MODE
Reserved for internal use
CONNECTION_STATUS
Status of the connection: NONE, 
CONNECTING, ACTIVE, WAITING, IDLE
274
Monitoring DRCP
You can monitor V$CPOOL_CONN_INFO to, for example, identify mis-configured machines that 
do not have the connection class set correctly. This view maps the machine name to the class 
name:
SQL> select cclass_name, machine from v$cpool_conn_info;
CCLASS_NAME                             MACHINE
--------------------------------------- ------------
. . .
CJ.OCI:SP:wshbIFDtb7rgQwMyuYvodA        cjlinux
. . .
In Oracle 11gR1 or in highly dynamic situations you can find this same information by turning 
on OCI tracing in the database:
$ sqlplus / as sysdba
SQL> alter system set events '10524 trace name context forever, level 1';
There is no need to restart the database. 
Now run the application to generate the trace files.
The trace file directory can be found by doing show parameter background_dump_dest in 
SQL*Plus. In the pooled server trace files, search for kpplsPopulate:
$ grep kpplsPopulate *.trc
. . .
orcl3_l005_28576.trc:kpplsPopulate: cso authenticated, 
key=(CJ*CJ.OCI:SP:wshbIFDtb7rgQwMyuYvodA**1*orcl3*ORA$BASE*)
You can see the correspondence between the "key" fields and the class names shown earlier 
in V$CPOOL_CC_STATS. Open the related trace file, for example orcl3_l005_28576.trc. Near 
the CJ.OCI:SP:wshbIFDtb7rgQwMyuYvodA entry it contains:
. . .
*** SESSION ID:(9.4985) 2012-06-18 16:16:29.973
*** SERVICE NAME:(orcl3) 2012-06-18 16:16:29.973
*** MODULE NAME:(httpd@cjlinux (TNS V1-V3)) 2012-06-18 16:16:29.973
*** ACTION NAME:() 2012-06-18 16:16:29.973
kpplsPostProcessState:(acquired=0)(call=OSESSKEY)
kpplsh_cso_release_hdlr: cso=(0xcbfdbd88)
Release (FALSE): cso=0xcbfdbd88
kpplsPreProcessState:(acquired=0)(call=OAUTH) 
Authentication complete: cso=0xcbfdbd88
kpplsPopulate: cso authenticated, 
key=(CJ*CJ.OCI:SP:wshbIFDtb7rgQwMyuYvodA**1*orcl3*ORA$BASE*)
kpplsClearSession: svsoCtx = (0xaf578bc8)
kpplsClearSession: Destroying session= (0xcf640268)
. . .
Reading back up the trace file to the MODULE NAME line shows the host name was cjlinux. 
This is the host Apache was running on. Check the php.ini of this machine, ensuring that it 
contains a valid oci8.connection_class parameter.
Tracing can now be turned off:
alter system set events '10524 trace name context forever, level 0';
275
PHP Connection Pooling and High Availability
High Availability With FAN and RAC
Clients that run in high availability configurations such as with Oracle RAC or Data Guard 
Physical Stand-By can take advantage of Fast Application Notification (FAN) events to allow 
applications to respond quickly to database node failures. FAN support in PHP may be used 
with or without DRCP – the two features are independent.
Without FAN, when a database instance or machine node fails unexpectedly, PHP 
applications may be blocked waiting for a database response until a TCP timeout expires. 
Errors are therefore delayed, sometimes up to several minutes.
By leveraging FAN events, PHP applications are quickly notified of failures that affect their 
established database connections. Connections to a failed database instance are pro-actively 
terminated without waiting for a potentially lengthy TCP timeout. This allows PHP scripts to 
recover quickly from a node or network failure. The application can reconnect and continue 
processing without the user being aware of a problem.
Also, all inactive network connections cached in PHP to the connection broker in case of 
DRCP, and persistent connections to the server processes or dispatcher in case of dedicated 
or shared server connections on the failed instances, are automatically cleaned up. 
A subsequent PHP connection call will create a new connection to a surviving RAC node, 
activated stand-by database, or even the restarted single-instance database.
Configuring FAN Events in the Database
To get the benefit of high availability, the database service to which the applications connect 
must be enabled to post FAN events. For example, to enable events on the service SALES in 
an Oracle 11gR2 database SALESDB: 
$ srvctl modify service –d SALESDB –s SALES –q TRUE 
The –q option indicates that AQ high availability events should be enabled.
Configuring PHP for FAN
With the OCI8 extension, a php.ini configuration parameter oci8.events
allows PHP to be 
notified of FAN events:
oci8.events = On
FAN support is only available when PHP uses OCI8 1.3 onwards, and is linked with Oracle 
Database 10g Release 2 or 11g libraries. PHP must connect to Oracle Database 10g Release 2 
or 11g. 
With older versions of Oracle Database, review the patches for Oracle bugs 7143299 (fixed 
in Oracle 11.2.0.1) and 8670389 (fixed in 11.2.0.2) to improve login times in various 
conditions when using oci8.events.
Application Deployment for FAN
The error codes returned to PHP will generally be the same as without FAN enabled, so 
application error handling can remain unchanged.
Alternatively, applications can be enhanced to reconnect and retry actions, taking 
advantage of the higher level of service given by FAN.
276
Documents you may be interested
Documents you may be interested