c# pdf to png : Adding a signature to a pdf form software SDK dll winforms wpf html web forms 05-welling-php-mysql-web56-part105

527
Programming Errors
you will get the following warning:
Warning: Wrong parameter count for strstr() in
/home/book/public_html/chapter25/error.php on line 1
That same statement within the following script is equally wrong:
<?php
if($var == 4)
{
strstr();
}
?>
Except in the possibly rare case in which the variable 
$var
has the value 
4
,the call to
strstr()
will not occur, and no warning will be issued.The PHP interpreter does not
waste time parsing sections of your code that are not needed for the current execution
of the script.You need to be sure that you test carefully!
Calling functions incorrectly is easy to do,but because the resulting error messages
identify the exact line and function call that are causing the problem,they are equally
easy to fix.They are difficult to find only if your testing process is poor and does not test
all conditionally executed code.When you test,one of the goals is to execute every line
of code at least once.Another goal is to test all the boundary conditions and classes of
input.
Reading or Writing Files
Although anything can go wrong at some point during your program’s useful life,some
problems are more likely than others.Because errors accessing files are likely enough to
occur,you need to handle them gracefully. Hard drives fail or fill up,and human error
results in directory permissions changing.
Functions such as 
fopen()
that are likely to fail occasionally generally have a return
value to signal that an error occurred. For 
fopen()
,a return value of 
false
indicates
failure.
For functions that provide failure notification,you need to carefully check the return
value of every call and act on failures.
Interaction with MySQL or Other Databases
Connecting to and using MySQL can generate many errors.The function 
mysqli_
connect()
alone can generate at least the following errors:
n
Warning: mysqli_connect() [function.mysqli-connect]: Can’t connect
to MySQL server on ‘localhost’ (10061)
n
Warning: mysqli_connect() [function.mysqli-connect]: Unknown MySQL
Server Host ‘hostname’ (11001)
n
Warning: mysqli_connect() [function.mysqli-connect]: Access denied
for user: ‘username’@’localhost’ (Using password: YES)
Adding a signature to a pdf form - 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
create a pdf form from excel; changing font size in a pdf form
Adding a signature to a pdf form - 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
pdf form creator; adding text fields to pdf acrobat
528
Chapter 25 Debugging
As you would probably expect,
mysqli_connect()
provides a return value of 
false
when an error occurs.This means that you can easily trap and handle these types of
common errors.
If you do not stop the regular execution of your script and handle these errors,your
script will attempt to continue interacting with the database.Trying to run queries and
get results without a valid MySQL connection results in your visitors seeing an unpro-
fessional-looking screen full of error messages.
Many other commonly used MySQL-related PHP functions such as 
mysqli_query()
also return 
false
to indicate that an error occurred.
If an error occurs,you can access the text of the error message using the function
mysqli_error()
,or an error code using the function 
mysqli_errno()
.If the last
MySQL function did not generate an error,
mysqli_error()
returns an empty string
and 
mysqli_errno()
returns 
0
.
For example,assuming that you have connected to the server and selected a database
for use,the code snippet
$result = mysqli_query($db, ‘select * from does_not_exist’ );
echo mysqli_errno($db);
echo ‘<br />’;
echo mysqli_error($db);
might output
1146
Table ‘dbname.does_not_exist’ doesn’t exist
Note that the output of these functions refers to the last MySQL function executed
(other than 
mysqli_error()
or 
mysqli_errno()
). If you want to know the result of a
command,make sure to check it before running others.
Like file interaction failures,database interaction failures will occur. Even after com-
pleting development and testing of a service,you will occasionally find that the MySQL
daemon (
mysqld
) has crashed or run out of available connections.If your database runs
on another physical machine,you are relying on another set of hardware and software
components that could fail—another network connection, network card,routers,and so
on between your Web server and the database machine.
You need to remember to check whether your database requests succeed before
attempting to use the result.There is no point in attempting to run a query after failing
to connect to the database and no point in trying to extract and process the results after
running a query that failed.
It is important to note at this point that there is a difference between a query failing
and a query that merely fails to return any data or affect any rows.
An SQL query that contains SQL syntax errors or refers to databases, tables, or
columns that do not exist will fail.The query
select * from does_not_exist;
C# PDF Digital Signature Library: add, remove, update PDF digital
Help to Improve the Security of Your PDF File by Adding Digital Signatures. Overview. XDoc.PDF also allows PDF security setting via digital signature.
add editable fields to pdf; add forms to pdf
C# Create PDF Library SDK to convert PDF from other file formats
PDF file. What's more, you can also protect created PDF file by adding digital signature (watermark) on PDF using C# code. Create
add image to pdf form; add form fields to pdf online
529
Programming Errors
will fail because the table name does not exist,and it will generate an error number and
message retrievable with 
mysqli_errno()
and 
mysqli_error()
.
A SQL query that is syntactically valid and refers only to databases,tables,and
columns that exist generally does not fail.The query might, however, return no results if
it is querying an empty table or searching for data that does not exist.Assuming that you
have connected to a database successfully and have a table called 
t1
and a column called
c1
,the query
select * from t1 where c1 = ‘not in database’;
will succeed but not return any results.
Before you use the result of the query,you need to check for both failure and no
results.
Connections to Network Services
Although devices and other programs on your system will occasionally fail,they should
fail rarely unless they are of poor quality.When using a network to connect to other
machines and the software on those machines,you need to accept that some part of the
system will fail often.To connect from one machine to another,you rely on numerous
devices and services that are not under your control.
At the risk of our being repetitive,you really need to carefully check the return value
of functions that attempt to interact with a network service.
A function call such as
$sp = fsockopen ( ‘localhost’, 5000 );
will provide a warning if it fails in its attempt to connect to port 5000 on the machine
localhost
,but it will display it in the default format and not give your script the option
to handle it gracefully.
Rewriting the call as
$sp = @fsockopen ( ‘localhost’, 5000, &$errorno, &$errorstr );
if(!$sp)
echo “ERROR: $errorno: $errorstr”;
will suppress the built-in error message,check the return value to see whether an error
occurred,and use your own code to handle the error message.As the code is written,it
will display an error message that might help you solve the problem.In this case, it
would produce the following output:
ERROR: 10035: A non-blocking socket operation could not be completed immediately.
Runtime errors are harder to eliminate than syntax errors because the parser cannot sig-
nal the error the first time the code is executed. Because runtime errors occur in
response to a combination of events,they can be hard to detect and solve.The parser
cannot automatically tell you that a particular line will generate an error.Your testing
needs to provide one of the situations that create the error.
C# PDF insert image Library: insert images into PDF in C#.net, ASP
to insert and add image, picture, digital photo, scanned signature or logo this technical problem, we provide this C#.NET PDF image adding control, XDoc
adding form fields to pdf; adding text to a pdf form
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit PowerPoint
for C# .NET, users can convert PowerPoint to PDF (.pdf) online, convert Users can perform text signature adding, freehand signature creation and date signature
add fields to pdf form; pdf create fillable form
530
Chapter 25 Debugging
Handling runtime errors requires a certain amount of forethought—to check for dif-
ferent types of failure that might occur and then take appropriate action.Simulating each
class of runtime error that might occur also takes careful testing.
We do not mean that you need to attempt to simulate every different error that
might occur.MySQL,for example,can provide one of around 200 different error num-
bers and messages.You do need to simulate an error in each function call that is likely to
result in an error and an error of each type that is handled by a different block of code.
Failure to Check Input Data
Often you make assumptions about the input data that will be entered by users.If this
data does not fit your expectations,it might cause an error,either a runtime error or a
logic error (detailed in the following section).
A classic example of a runtime error occurs when you are dealing with user input
data and you forget to apply 
addslashes()
to it.This means if you have a user with a
name such as O’Grady that contains an apostrophe,you will get an error from the data-
base function if you use the input in an insert statement inside single quotation marks.
We discuss errors because of assumptions about input data in more detail in the next
section.
Logic Errors
Logic errors can be the hardest type of error to find and eliminate.This type of error
occurs when perfectly valid code does exactly what it is instructed to do,but that was
not what the writer intended.
Logic errors can be caused by a simple typing error,such as
for ( $i = 0; $i < 10; $i++ );
{
echo ‘doing something<br />’;
}
This snippet of code is perfectly valid.It follows valid PHP syntax.It does not rely on
any external services,so it is unlikely to fail at runtime.Unless you looked at it very
carefully,it probably will not do what you think it will or what the programmer 
intended it to do.
At a glance, it looks as if it will iterate through the 
for
loop 10 times, echoing
“doing something”
each time.The addition of an extraneous semicolon at the end of
the first line means that the loop has no effect on the following lines.The 
for
loop will
iterate 10 times with no result, and then the 
echo
statement will be executed once.
Because this snippet is a perfectly valid, but inefficient,way to write code to achieve
this result,the parser will not complain.Computers are very good at some things,but
they do not have any common sense or intelligence.A computer will do exactly as it is
told.You need to make sure that what you tell it is exactly what you want.
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit PDF
Viewer for C# .NET provides permanent annotations adding feature, all enables you to create signatures to PDF, including freehand signature, text and
add picture to pdf form; can save pdf form data
VB.NET PDF Digital Signature Library: add, remove, update PDF
the Security of Your PDF File by Adding Digital Signatures in VB to be respected, XDoc.PDF also allows PDF such security setting via digital signature.
change text size pdf form; add fields to pdf
531
Variable Debugging Aid
Logic errors are not caused by any sort of failure of the code,but merely a failure of
the programmer to write code that instructs the computer to do exactly what she want-
ed.As a result,errors cannot be detected automatically.You are not told that an error has
occurred,and you are not given a line number where you can look for the problem.
Logic errors are detected only by proper testing.
A logic error such as the previous trivial example is fairly easy to make,but also easy
to correct because the first time your code runs,you will see output other than what
you expected.Most logic errors are a little more insidious.
Troublesome logic errors usually result from developers’assumptions being wrong.
Chapter 24,“Using PHP and MySQL for Large Projects,”recommended using other
developers to review code to suggest additional test cases and using people from the tar-
get audience rather than developers for testing.Assuming that people will enter only cer-
tain types of data is very easy to do and an error that is very easy to leave undetected if
you do your own testing.
Let’s say that you have an Order Quantity text box on a commerce site.Have you
assumed that people will enter only positive numbers? If a visitor enters –10,will your
software refund his credit card with 10 times the price of the item?
Suppose that you have a box to enter a dollar amount.Do you allow people to enter
the amount with or without a dollar sign? Do you allow people to enter numbers with
thousands separated by commas? Some of these things can be checked at the client side
(using,for example,JavaScript) to take a little load off your server.
If you are passing information to another page,has it occurred to you that some charac-
ters might have special significance in a URL,such as spaces in the string you are passing?
An infinite number of logic errors is possible.There is no automated way to check for
these errors.The only solution is,first,to try to eliminate assumptions that you have
implicitly coded into the script and,second,test thoroughly with every type of valid and
invalid input possible,ensuring that you get the anticipated result for all.
Variable Debugging Aid
As projects become more complex,having some utility code to help you identify the
cause of errors can be useful.A piece of code that you might find useful is contained in
Listing 25.1.This code echoes the contents of variables passed to your page.
Listing 25.1 dump_variables.php—This Code Can Be Included in Pages to Dump
the Contents of Variables for Debugging
<?php
// these lines format the output as HTML comments
// and call dump_array repeatedly
echo “\n<!-- BEGIN VARIABLE DUMP -->\n\n”;
echo “<!-- BEGIN GET VARS -->\n”;
VB.NET PDF Library SDK to view, edit, convert, process PDF file
Capable of adding PDF file navigation features to your VB.NET program. How To Tutorials. Password, digital signature and PDF text, image and page redaction
adding a signature to a pdf form; best way to make pdf forms
.NET PDF SDK - Description of All PDF Processing Control Feastures
Add signature image to PDF file. PDF Hyperlink Edit. Support adding and inserting hyperlink (link) to PDF document; Allow to create, edit, and remove PDF bookmark
create a pdf form to fill out; add fillable fields to pdf online
532
Chapter 25 Debugging
echo ‘<!-- ‘.dump_array($_GET).” -->\n”;
echo “<!-- BEGIN POST VARS -->\n”;
echo ‘<!-- ‘.dump_array($_POST).” -->\n”;
echo “<!-- BEGIN SESSION VARS -->\n”;
echo ‘<!-- ‘.dump_array($_SESSION).” -->\n”;
echo “<!-- BEGIN COOKIE VARS -->\n”;
echo ‘<!-- ‘.dump_array($_COOKIE).” -->\n”;
echo “\n<!-- END VARIABLE DUMP -->\n”;
// dump_array() uses the builtin print_r
// and escapes out any HTML end comments
function dump_array($array)
{
$output = print_r($array, true);
$output = str_replace(‘-->’, ‘-- >’, $output);  
return $output;
}
?> 
This code outputs four arrays of variables that a page receives.If a page was called with
GET
variables,
POST
variables,cookies, or it has session variables,they will be output.
Here, we put the output within an HTML comment so that it is viewable but does
not interfere with the way the browser renders visible page elements.This is a good way
to generate debugging information. Hiding the debug information in comments,as in
Listing 25.1,allows you to leave in your debug code until the last minute.We used the
dump_array()
function as a wrapper to 
print_r()
.The 
dump_array()
function just
escapes out any HTML end comment characters.
The exact output depends on the variables passed to the page,but when added to
Listing 22.4,one of the authentication examples from Chapter 22,“Using Session
Control in PHP,”it adds the following lines to the HTML generated by the script:
<!-- BEGIN VARIABLE DUMP -->
<!-- BEGIN GET VARS -->
<!-- Array
(
)
-->
Listing 25.1 Continued 
XDoc.HTML5 Viewer for .NET, All Mature Features Introductions
to search text-based documents, like PDF, Microsoft Office typing new signature, deleting added signature from the After adding such a control button, with a
change font in pdf form; adding image to pdf form
VB.NET PDF insert image library: insert images into PDF in vb.net
Import graphic picture, digital photo, signature and logo into PDF document. This smart and mature PDF image adding component of RasterEdge VB.NET PDF
chrome save pdf form; add text field to pdf acrobat
533
Error Reporting Levels
<!-- BEGIN POST VARS -->
<!-- Array
(
[userid] => testuser
[password] => password
)
-->
<!-- BEGIN SESSION VARS -->
<!-- Array
(
)
-->
<!-- BEGIN COOKIE VARS -->
<!-- Array
(
[PHPSESSID] => b2b5f56fad986dd73af33f470f3c1865
)
-->
<!-- END VARIABLE DUMP -->
You can see that it displays the 
POST
variables sent from the login form on the previous
page:
userid
and 
password
.It also shows the session variable used to keep the user’s
name in:
valid_user
.As discussed in Chapter 22,PHP uses a cookie to link session
variables to particular users.The script echoes the pseudo-random number,
PHPSESSID
,
which is stored in that cookie to identify a particular user.
Error Reporting Levels
PHP allows you to set how fussy it should be with errors.You can modify what types of
events generate messages.By default,PHP reports all errors other than notices.
The error reporting level is assigned using a set of predefined constants, shown in
Table 25.1.
Table 25.1 Error Reporting Constants
Value
Name
Meaning
1
E_ERROR
Report fatal errors at runtime
2
E
_
WARNING
Report nonfatal errors at runtime
4
E_PARSE
Report parse errors
8
E_NOTICE
Report notices, notifications that something you have done
might be an error
16
E_CORE_ERROR
Report failures in the startup of the PHP engine
32
E_CORE_WARNING
Report nonfatal failures during the startup of the PHP
engine
534
Chapter 25 Debugging
64
E_COMPILE_ERROR
Report errors in compilation
128
E_COMPILE_WARNING
Report nonfatal errors in compilation
256
E_USER_ERROR
Report user-triggered errors
512
E_USER_WARNING
Report user-triggered warnings
1024
E_USER_NOTICE
Report user-triggered notices
2047
E_ALL
Report all errors and warnings
2048
E_STRICT
Reports use of deprecated and unrecommended behavior;
not included in 
E_ALL
but very useful for code refactoring
Each constant represents a type of error that can be reported or ignored.If, for instance,
you specify the error level as 
E_ERROR
,only fatal errors will be reported.These constants
can be combined using binary arithmetic,to produce different error levels.
The default error level—report all errors other than notices—is specified as follows:
E_ALL & ~E_NOTICE
This expression consists of two of the predefined constants combined using bitwise
arithmetic operators.The ampersand (
&
) is the bitwise AND operator and the tilde (
~
) is
the bitwise NOT operator.This expression can be read as 
E_ALL AND NOT E_NOTICE
.
E_ALL
itself is effectively a combination of all the other error types except for
E_STRICT
.It could be replaced by the other levels combined together using the bitwise
OR operator (
|
):
E_ERROR | E_WARNING | E_PARSE | E_NOTICE | E_CORE_ERROR | E_CORE_WARNING |
E_COMPILE_ERROR |E_COMPILE_WARNING | E_USER_ERROR | E_USER_WARNING |
E_USER_NOTICE
Similarly,the default error reporting level could be specified by all error levels except
E_NOTICE
combined with OR:
E_ERROR | E_WARNING | E_PARSE | E_CORE_ERROR | E_CORE_WARNING | E_COMPILE_ERROR |
E_COMPILE_WARNING | E_USER_ERROR | E_USER_WARNING | E_USER_NOTICE
Altering the Error Reporting Settings
You can set the error reporting settings globally, in your 
php.ini
file or on a per-script
basis.
To alter the error reporting for all scripts,you can modify these four lines in the
default 
php.ini
file:
error_reporting =       E_ALL & ~E_NOTICE
display_errors  =       On
log_errors      =       Off
track_errors    =       Off
Table 25.1 Continued 
Value
Name
Meaning
535
Altering the Error Reporting Settings
The default global settings are to
n
Report all errors except notices
n
Output error messages as HTML to standard output
n
Not log error messages to disk
n
Not track errors,storing the error in the variable 
$php_errormsg
The most likely change you will make is to turn the error reporting level up to 
E_ALL | E_STRICT
.This change results in many notices being reported,for incidents
that might indicate an error,or might just result from the programmer taking advantage
of PHP’s weakly typed nature and the fact that it automatically initializes variables to 
0
.
While debugging,you might find it useful to set the 
error_reporting
level higher.If
you are providing useful error messages of your own,the production code would be
more professional looking if you turn 
display_errors
off and turn 
log_errors
on,
while leaving the 
error_reporting
level high.You then can refer to detailed errors in
the logs if problems are reported.
Turning 
track_errors
on might help you to deal with errors in your own code,
rather than letting PHP provide its default functionality.Although PHP provides useful
error messages, its default behavior looks ugly when things go wrong.
By default,when a fatal error occurs,PHP outputs
<br>
<b>Error Type</b>: error message in <b>path/file.php</b>
on line <b>lineNumber</b><br>
and stops executing the script. For nonfatal errors,the same text is output,but execution
is allowed to continue.
This HTML output makes the error stand out but looks poor.The style of the error
message is unlikely to fit the rest of the site’s look. It might also result in some users see-
ing no output at all if the page’s content is being displayed within a table and their
browser is fussy about valid HTML.HTML that opens but does not close table ele-
ments,such as
<table>
<tr><td>
<br>
<b>Error Type</b>:  error message in <b>path/file.php</b>
on line <b>lineNumber</b><br>
is rendered as a blank screen by some browsers.
You do not have to keep PHP’s default error handling behavior or even use the same
settings for all files.To change the error reporting level for the current script,you can call
the function 
error_reporting()
.
536
Chapter 25 Debugging
Passing an error report constant,or a combination of them,sets the level in the same
way that the similar directive in 
php.ini
does.The function returns the previous error
reporting level.A common way to use the function is like this:
// turn off error reporting
$old_level = error_reporting(0);
// here, put code that will generate warnings
// turn error reporting back on
error_reporting($old_level);
This code snippet turns off error reporting,allowing you to execute some code that is
likely to generate warnings that you do not want to see.
Turning off error reporting permanently is a bad idea because it makes finding your
coding errors and fixing them more difficult.
Triggering Your Own Errors
The function 
trigger_error()
can be used to trigger your own errors.Errors created
in this way are handled in the same way as regular PHP errors.
The function requires an error message and can optionally be given an error type.
The error type needs to be one of 
E_USER_ERROR
,
E_USER_WARNING
,or 
E_USER_NOTICE
.
If you do not specify a type,the default is 
E_USER_NOTICE
.
You use 
trigger_error()
as follows:
trigger_error(‘This computer will self destruct in 15 seconds’, E_USER_WARNING);
Handling Errors Gracefully
If you come from a C++ or Java background,you are probably comfortable using
exceptions.Exceptions allow functions to signal that an error has occurred and leave
dealing with the error to an exception handler.Exceptions were added to PHP only in
version 5 but are an excellent way to handle errors in large projects.They were ade-
quately covered in Chapter 7,“Exception Handling,”so they will not be revisited here.
If you need your code to work on PHP4, you can simulate similar behavior with
user-triggered errors and user-defined error handlers, but this behavior will become less
important now that PHP supports exceptions.You have already seen how you can trig-
ger your own errors.You can also provide your own error handlers to catch errors.
The function 
set_error_handler()
lets you provide a function to be called when
user-level errors,warnings,and notices occur.You call 
set_error_handler()
with the
name of the function you want to use as your error handler.
Your error handling function must take two parameters:an error type and an error
message.Based on these two variables,your function can decide how to handle the
error.The error type must be one of the defined error type constants.The error message
is a descriptive string.
Documents you may be interested
Documents you may be interested