pdf viewer c# : How to add a picture to a pdf document software application dll winforms windows web page web forms OReilly_-_POSIX_Programmers_Guide12-part1945

One of the original ideas of the UNIX system was to build complex programs out of simple
ones. A pipeline allows you to use the output of one program as the input to the next program.
pipe 
is a type of file where one process writes to one end and another process reads from the
other end. Pipes are created by the 
pipe()
function, which is defined as:
int pipe(int fildes[2]);
P
age 97
It places an open file descriptor into 
fildes[0]
and 
fildes[1]
. The file descriptor in
fildes[0]
is the read end of the pipe and the file descriptor in 
fildes[1]
is the write
end of the pipe.
Pipes are quite portable. POSIX defines a number of properties for pipes. You can count on all
POSIX systems supporting these features. Older UNIX systems may or may not support these
properties and your program will be more portable if you do not depend o
n these properties.
·
There is no file offset associated with a pipe. Each write appends to the end of the pipe.
·
A write of fewer than 
PIPE_BUF
bytes is atomic; the data will not be interleaved with
data from other processes writing to the same pipe. A write of more than 
PIPE_BUF
may
have data interleaved in arbitrary ways.
For example, if 
PIPE_BUF
is 5120,
*
a write of 5000 bytes will be contiguous. A write of
6000 bytes may be broken into 60 100-byte chunks.
·
If 
O_NONBLOCK
is not set, a write will return after writing all the requested data.
·
If 
O_NONBLOCK
is set, a write of fewer than 
PIPE_BUF
bytes will either write the entire
buffer or write nothing. A write of more than 
PIPE_BUF
bytes will write what it can.
You can also create a "named pipe" or FIFO using the 
mkfifo()
function. This is defined as:
int mkfifo(const char *path, mode_t mode);
and creates a new FIFO special file named by the string pointed to by 
path
. The file
permission bits of the new FIFO are set from mode. Permission bits and the mode argument
were described in Chapter 4, 
Files and Directories.
Because pipes are used for interprocess communication, I will leave the discussion for the next
chapter.
File Creation Mask
There is one file operation that does not fit into any other category: set file creation mask. Each
process has a file creation mask. The 
open()
creat()
mkdir()
, and 
mkfifo()
calls
use the file creation mask to turn off permission bits when they create f
iles. For example,
setting the 
S_IRWXO
bits in the mask would turn off read, write, and execute permission bits
for the "other" class.
* The value of 
PIPE_BUF
is usually 4096 or 5120. POSIX requires that it must be 512 or greater.
How to add a picture to a pdf document - insert images into PDF in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sample C# code to add image, picture, logo or digital photo into PDF document page using PDF page editor control
add photo to pdf; add jpg to pdf online
How to add a picture to a pdf document - VB.NET PDF insert image library: insert images into PDF in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Guide VB.NET Programmers How to Add Images in PDF Document
add image to pdf; how to add jpg to pdf file
P
age 98
The umask( ) Function
The 
umask()
function is defined as:
mode_t umask(mode_t cmask);
It sets the file creation mask to 
cmask
and returns the previous value. No errors are detected.
The 
umask()
function itself is very portable. Programs developed where the 
umask
value of
000
(no protection) is used may not work in a high security environment where the 
umask
value may be 
077
. It is a good idea to test your applications with a 
umask
val
ue of 
077
. You
can avoid this problem by executing a 
umask(0)
at the start of your program; however, that
may not be what the end-user of your software wants.
Mixing the Levels
Sometimes you need to perform a low-level call on a file you are using at a high level. For
example, you may want to set the close-on-exec flag for a stream. In other cases, you may need
to convert a file descriptor to a stream; for example, to write a pip
e using 
fprintf()
calls.
There are some handy functions to perform this mapping.
The fdopen() Function
The 
fdopen()
function associates a stream with a file descriptor. The function is defined as:
FILE *fdopen(int fildes, const char *type);
The 
fildes
argument is the file descriptor you want to convert. The 
type
argument is
exactly the same as described in Chapter 3, 
Standard File and Terminal I/O, 
for 
fopen()
except the file is never truncated.
In general, the functions described in Chapter 3 are more portable than the ones described in
this chapter. The 
fdopen()
call is a handy way to avoid using the low-level routines when
you are given a file descriptor.
The fileno() Function
The 
fileno()
function returns the file descriptor associated with a stream. It is defined as:
int fileno(FILE *stream);
A return value of 
-1
indicates an error; however, 
fileno()
is not required to detect an
invalid argument and I am sure that some systems do not.
The file number returned by 
fileno()
can be used by the functions described in this chapter.
For example, 
fcntl()
can be used to lock and unlock records.
P
age 99
Pitfalls
C# TIFF: How to Insert & Burn Picture/Image into TIFF Document
Support adding image or picture to an existing new REImage(@"c:\ logo.png"); // add the image powerful & profession imaging controls, PDF document, tiff files
add image pdf; adding image to pdf in preview
VB.NET TIFF: How to Draw Picture & Write Text on TIFF Document in
Dim drawing As RaterEdgeDrawing = New RaterEdgeDrawing() drawing.Picture = "RasterEdge" drawing powerful & profession imaging controls, PDF document, tiff files
how to add a picture to a pdf file; how to add image to pdf in acrobat
Accessing a single open file description using both streams and file descriptors can cause
problems. Attempting to write a file using both 
fprintf()
and 
write()
, for example, can
cause data to be written out of order and may work differently from system to
system.
There are safe operations. For example, 
fcntl()
can be used to perform record locking
while 
fread()
and 
fwrite()
are used to update the file.
If all of the operations that could affect the file offset (for example 
read()
write()
,
lseek()
scanf()
printf()
, and so on) are done exclusively through streams,
everything will work correctly. If all of the operations that could affect the file offset
are done
exclusively through file descriptor calls, everything will work correctly.
If you have been exclusively using file descriptor functions (
read(), write(),
lseek()
) to access the file, you can switch to using stream functions exclusively
(
fgets(),fputs()
, etc.) at any point.
To switch from using stream functions exclusively to using file descriptor functions, special
care must be used. If the stream is unbuffered and the 
ungetc()
function has not been used,
you can switch to using file descriptor functions.
In most other cases
*
the interaction is not defined and the functions should not be mixed.
Portability Lab
To review the contents of this chapter, try to do the following exercises:
1.
If you were to write a routine to simulate the library function 
printf()
and call the
write()
function directly from your code, would it be faster or slower than the library
routine. Why?
2.
What is the effect of setting the 
O_CREAT
flag when opening an existing file?
3.
The fast file copy example program in this chapter claims to be fast because it uses only
one read and one write to copy the entire file. When might this be slower than using several
reads and writes?
* There are a number of obscure cases which are still defined. For example, if a file is open for read
and positioned at the end of the file, we can freely switch between 
fread()
and 
read()
.
If there is an overwhelming reason to mix stream-based and descriptor-based I/O, read section 8.2.3
of the POSIX standard several times.
P
age 100
4.
Why is the sequence: 
flags = fcntl(fildes,F_GETFD); 
fcntl(fildes,F_SETFD,flags | O_NONBLOCK); 
a better way to set the 
O_NONBLOCK
flag for a file than the following?
fcntl(fildes,F_SETFD,O_NONBLOCK);
5.
Assume an application opens a file and sets some exclusive record locks. While the file is
C# Word - Paragraph Processing in C#.NET
Add references: CreateParagraph(); //Create a picture for para IPicture picture = para.CreatePicture(imageSrcPath); //Save the document doc0.Save
adding image to pdf file; add picture to pdf
VB.NET Image: Create Code 11 Barcode on Picture & Document Using
file, apart from above mentioned .NET core imaging SDK and .NET barcode creator add-on, you also need to buy .NET PDF document editor add-on, namely, RasterEdge
attach image to pdf form; add jpg to pdf acrobat
open, you attempt to copy it using the fast file copy example program given in this chapter.
What would happen? Why? 
6.
Why would one use 
lseek()
instead of 
fseek()
?
7.
Why would an application call 
umask()
? Why not just set the permission bits correctly in
the call to 
open()
?
8.
What practical reason is there for the use of the 
fileno()
function? What about
fdopen()
?
9.
What problems might occur if 
printf()
and 
write()
are intermixed writing a file?
How can these problems be eliminated?
P
age 101
Chapter 6
Working with Processes
This chapter covers process creation, process termination, and signals. Process creation
involves the 
fork()
and 
exec(
) calls, that are familiar to a UNIX programmer. Process
termination involves the 
wait()
and 
waitpid()
calls. POSIX.1 adds some new ideas
here: signals are different in POSIX. Although based on Berkeley signals, the POSIX library
defines different functions that have somewhat different behavior than what you may be
familiar with from using BSD.
Process Creation
The 
fork()
and 
exec()
functions are present in all UNIX systems, and POSIX documented
the common existing practice. In this section, we look at the process creation features that
POSIX guarantees to be portable.
The fork() Function
A process is created with the 
fork()
system call. It takes no arguments and creates a new
process called a 
child. 
If it fails, it returns 
-1
.
The original process is called the 
parent, 
the child is an exact copy of the parent except for the
following:
·
The child process has a unique process ID.
·
The child's parent process ID is set to the process ID of the process executing the 
fork()
.
·
The child has its own copy of the parent's file descriptors. The child has access to all of the
parent's open files.
·
The child's run time is set to zero.
·
Pending alarms are cleared for the child.
VB.NET PowerPoint: Add Image to PowerPoint Document Slide/Page
clip art or screenshot, the picture will be AddPage", "InsertPage" and "DeletePage" to add, insert or & profession imaging controls, PDF document, tiff files
add photo to pdf form; adding image to pdf
VB.NET Image: VB.NET Planet Barcode Generator for Image, Picture &
on Overview. VB.NET Planet Barcode Creator Add-on within Generate Planet Barcode on Picture & Image in VB.NET. In for adding Planet barcode image to PDF, TIFF or
add an image to a pdf acrobat; add image to pdf in preview
·
The set of pending signals is set to the empty set.
·
File locks are not inherited.
The child starts out life right after the 
fork()
call that created it. The 
fork()
call returns
zero to the child and returns the process ID of the newly created child to the parent. A program
that calls 
fork()
typically tests the return value and does one 
thing in the parent and
something different in the child.
P
age 102
The 
fork()
call is very portable. BSD has a special flavor of 
fork()
called 
vfork()
.
The 
vfork()
call is a special case designed to speed up the 
fork()/exec()
operation.
You may replace a BSD 
vfork()
operation with 
fork()
to make your program more
portable
. You can also do the following:
#ifdef BSD 
pid = vfork(); 
#else 
pid = fork(); 
#endif 
to retain the performance boost on BSD systems while being POSIX-conforming.
*
The exec() Family of Function
A child process can run another program. For example, most commands cause the shell to
fork
a new process and then 
exec
a program.
There is no function named 
exec()
: instead, there is a family of similar calls, each of which
have slightly different arguments. The family is:
int execl(const char *path, const char *arg, ...); 
int execv(const char *path, char * const argv[]); 
int execle(const char *path, const char *arg, ...); 
int execve(const char *path, char * const argv[], 
char * const *envp); 
int execlp(const char *file, const char *arg, ...); 
int execvp(const char *file, char * const argv[(); 
The 
exec
family of calls replaces the current process image with a new program. The new
program is read from an ordinary executable file. There is no return from a successful exec;
instead, the new program is started.
The 
main()
function in the new program is called as:
int main(int argc, char *argv[]);
where 
argc
is the argument count and 
argv
is an array of character pointers to the arguments
themselves. In addition, the variable:
extern char **environ;
is initialized as a pointer to an array of character pointers to the environment strings. The
VB.NET Image: Image Cropping SDK to Cut Out Image, Picture and
SDK; VB.NET image cropping method to crop picture / photo; VB.NET image cropping control add-on needs a PC com is professional provider of document, content and
how to add an image to a pdf file in acrobat; how to add an image to a pdf in preview
VB.NET Image: Image Scaling SDK to Scale Picture / Photo
this VB.NET image scaling control add-on, we API, developer can only scale one image / picture / photo at com is professional provider of document, content and
add signature image to pdf acrobat; add photo to pdf reader
argv
and environ arrays are each terminated by a 
NULL
pointer. The 
NULL
pointer
terminating the 
argv
array is not counted in 
argc
.
The argument 
file
should contain just the filename of the new program. The path prefix for
this file is obtained by a search of the directories passed as the environment variable 
PATH
.
The call 
execlp("more"
,
"more",(char*)0)
; looks for 
more
in each directo
ry in the
search path.
*
The BSD 
vfork()
function must be followed by an 
exec
.
P
age 103
The argument 
path
points to a pathname that identifies the file to be executed. No searching
takes place on calls with a 
path
argument.
The 
const char *arg
and subsequent ellipses in the 
execl()
execlp()
, and
execle()
functions can be thought of as a list of one or more pointers to null-terminated
character strings that represent the argument list available to the new program. The first
a
rgument should point to a file containing the program to be started, and the last argument
should be a 
NULL
pointer. For the 
execle()
function, the environment pointer follows the
NULL
pointer that terminates the argument list.
The argument 
envp
to 
execve()
, and the final argument to 
execle()
, name an array of
character pointers to null-terminated strings. These strings constitute the environment for the
new process. The environment array is terminated by a 
NULL
pointer. For
exec
l(),execv(),execlp()
, and 
execvp()
, the environment for the new program is
inherited from the caller.
When you terminate the list with 
NULL
, make sure that you cast it to a pointer with (
char *
).
On some 80x86 or 680x0 systems, an 
int
is 16 bits but a pointer is 32 bits. A naked zero will
not work on those systems.
The POSIX standard does not say exactly what is a legal "executable file." This is intentional.
Systems based on BSD allow shell scripts as executable files, while AT&T systems do not.
*
Some systems allow shell scripts for the 
execlp()
and 
execvp()
functio
ns but for no
others. If the file you are trying to execute is not executable, the call will return 
-1
with
errno
set to 
ENOEXEC
.
The requirements for an application state that the value passed as the first argument must be a
filename associated with the process being started. When you 
exec()
a program, you should
pass the filename (not the full path) as 
argv[0]
. The most common usag
e of 
argv[0]
is in
printing error messages. The' standard does not say that 
argv[0]
must be the actual filename
of the executable file. For example, the login utility may prefix the filename with a hyphen to
indicate to the command interpreter being invoke
d that it is a "login shell."
Example: Piping Output Through more
The actions of 
fork()
and 
exec
can be made much clearer by using an example. Consider
the sample program at the end of Chapter 3, 
Standard File and Terminal I/O. 
This program
writes square roots to a file. Let's modify the program to display the square roo
ts on the screen.
To allow the user to control the output, we will use the 
more
program to display the results.
* This applies only to the 
exec()
functions.
P
age 104
All we need to do is replace the 
write_file
function with a new function to send the output
to the display. Here is what that new function looks like:
void display(long start,long stop) 
FILE *fileid; 
int fildes[2]; 
long i; 
double f; 
int status; 
/* The first thing we do is create a pipe. The array fildes 
* contains a file descriptor for each end of the pipe, 
* where fildes[0] is the "
read" side and fildes[1] is 
* the "write" side. 
*/ 
if (pipe(fildes) != 0) PANIC; 
/* Next we attempt to create a child using the fork() 
* function. This has three possible returns: failure, 
* normal return to child, and normal re
turn to the parent. 
* The switch statement covers the first two cases. Failure 
* is detected and a PANIC message is issued. Otherwise, we 
* get things set for the child. 
*/ 
switch (fork()) 
case -1: 
PANIC; 
break; 
case 0: 
/* 
* This is the child. 
* The first step here is to change the child's 
* standard input to be the pipe we just created. 
* Doing this uses an old UNIX trick. We close 
* the existing STDIN file
and then call 
* dup() to create a new descriptor. This 
* will use the lowest available file descriptor. 
* Since we just closed STDIN, dup() will reuse it 
* and standard input will be connected to the 
* pipe. 
*       
* It is now required to c
lose the child's side of 
* both fildes[0] and fildes[1]. The child will 
* see EOF, when all writers of the pipe close 
* their side. If we forgot to close the side 
* inherited from the parent, the program would 
* never terminate. 
*/ 
if (close(STDIN_FILENO) != 0) PANIC; 
if (dup(fildes[0]) ! STDIN_FILENO) PANIC; 
/* Close left over file descriptors */ 
if (close(fildes[0]) != 0) PANIC; 
if (close(fildes[l]) != 0) PANIC; 
/
* The final step for the child is to replace 
* itself with the more program.  The execlp() 
* function does that for us. 
*/ 
P
age 105
execlp("more","more",(char *)0); 
PANIC; /* Should never return */ 
/* 
* This is the parent 
*/ 
/* In the meantime, the parent will skip both cases of the 
* switch statement and 
hit the call to fdopen().  The 
* fdopen() function converts a file descriptor to a stream. 
* This allows the use of standard I/O functions, like 
* fprintf() to do our output. 
*/ 
fileid = fdopen(fildes[l],"w"); 
if (close(fildes[0]) != 0)
PANIC; 
if (fprintf(fileid,"     N         SQRT(N)\n") < 0) 
PANIC; 
/* Next, we do all our computing. The output will flow 
* through the pipe to the more program which will display 
* it. 
*/ 
for (i=start; i <= stop; i++) 
f = (float)i; 
if (fprintf(fileid, "%10.0f   %10.6f\n", 
f,sqrt(f)) < 0) 
perror("Error writing output file"); 
abort(); 
/* When we have computed all of our results, we close fileid. 
* This causes more to see EOF and exit.  Note: the fclose() 
* function will perform a close() on fildes[1] as part of 
* its work. We do not have to (can't) close it again. 
*/ 
if (fclose(fileid) != 0) PANIC; 
/* The last step is the wait(). This waits for more to exit.*/ 
(void)wait(&status); 
Portability Note
The first argument to 
execlp()
is "
more
". This will cause the 
execlp()
function to
search the path specified by the 
PATH
environment variable. This may not get us the system
utility more. You may instead find some other program called more. This is a secur
ity hole (or
at least a reliability hole).
Another choice is to build in the absolute pathname for the more utility. Something like
/bin/more
will work on many UNIX systems but is not guaranteed to work on all POSIX
systems.
A third choice is to have some sort of installation procedure which asks for a path name for
more and includes it as part of building this application. This is one of the more common
techniques used today.
P
age 106
When POSIX.2 is an approved (and implemented) standard, it will specify functions to find the
system utilities. Until then you will have to use one of the ideas given above.
Process Termination
You sometimes need to wait for children processes to complete their work. You also need to
terminate the current program and other programs. Let's look at some of the ways of doing this.
The wait() and waitpid() Functions
In the previous example we used the 
wait()
function to make sure that more was done. Let's
now look at 
wait()
in some more detail. The function is defined as:
pid_t wait(int *stat_loc);
and waits for status to become available for a child process. A call to 
wait()
with an 
int
*
parameter is very portable and works on all UNIX systems.
The 
wait()
function returns the process ID of a terminated child. If the argument 
stat_loc
is not 
NULL
, information is stored in the location pointed to by 
stat_loc
. If the child
returned a value of zero from 
main()
or passed a value of zero to 
exit()
, the
value stored
in the location pointed to by 
stat_loc
will be zero. The status value can interpreted using
the following macros:
WIFEXITED(stat_value)
Evaluates to a non-zero value if status was returned for a
child that terminated normally.
WEXITSTATUS(stat_value)
Evaluates to the low-order eight bits of the 
status
argument that the child passed to 
exit()
, or the value the
child pr
ocess returned from 
main()
. This macro can be
used only if 
WIFEXITED
returned a non-zero value.
WIFSIGNALED(stat_value)
Evaluates to a non-zero value if status was returned for a
child that terminated due to a signal that was not caught.
WTERMSIG(stat_val
ue )
Evaluates to the number of the signal that caused the
termination of the process. This macro can be used only if
WIFSIGNALED
returned a non-zero value.
WIFSTOPPED(stat_value)
Evaluates to a non-zero value if the status was returned for
a child that is
currently stopped. The 
waitpid()
function
with the 
WUNTRACED
option is the only way this value can
be returned.
* Signals are covered in detail later in this chapter.
P
age 107
WSTOPSIG( stat_value)
Evaluates to the number of the signal that caused the child
process to stop. This macro can be used only if
WIFSTOPPED
returned a non-zero value.
Here is how you might use these macros:
pid = wait(&s);         /* s gets termination status 
* of child 
*/ 
if (pid==-l) PANIC; 
if ((WIFEXITED(s) != 0) && ((WEXITSTATUS(s) != 0)) 
fprintf(stderr,"Child 
exited with code %d\n", 
WEXITSTATUS(s)); 
if (WIFSIGNALED(S)) 
fprintf(stderr,"Child died with signal %d\n", 
WTERMSIG(s)); 
These macros are POSIX inventions so they will not work on older systems. The following
definitions will work on most BSD and System V systems:
#define  LO(s)          ((int)((s)&0377)) 
#define  HI(s)          ((int)(((s)>>8)&0377)) 
#define  WIFEXITED(s)   (LO(s)==O) 
#define  WEXITSTATUS(s) HI(s) 
#define  WIFSIGNALED(s) ((LO(s)>0)&&(HI(s)==0)) 
#define  WTERMSIG(s)    (LO(s)&0177) 
#define  WIFSTOPPED(s)  ((LO(s)==0177)&&(HI(s)!=0)) 
#define  WSTOPSIG(s)    HI(s) 
Traditional UNIX systems provided only the 
wait()
function. The POSIX working group felt
the need for better control and added the 
waitpid()
function. It is defined as:
pid_t waitpid(pid_t pid, int *stat_loc, int options);
The 
pid
argument is one of the following:
-1
To wait for any child process. This is the same as 
wait()
.
Documents you may be interested
Documents you may be interested