c# pdf viewer itextsharp : Reorder pages in pdf file software control dll windows web page wpf web forms Windows%20Powershell%20in%20Action%202nd%20Edition57-part1513

540
CHAPTER 13
R
EMOTING
CONFIGURING
APPLICATIONS
AND
SERVICES
NOTE
You might logically assume that wildcards would be permitted 
in this list. They aren’t. The only pattern that has a special significance 
is when the list contains a single 
*
. Pattern matching may be added in 
future releases, but although it was considered, it wasn’t implemented 
in PowerShell v2.
Let’s work through an example showing how these lists work. First, you’ll get the 
absolute path  to the 
ipconfig
command using the 
Definition
property on its 
CommandInfo
object:
PS (1) > $ipp = (Get-Command ipconfig.exe).Definition
This is an easy way of getting the full path to the command, regardless of which oper-
ating system you’re on. Once you have that, you’ll clear the Applications list. (You 
had to get the 
CommandInfo
for 
ipconfig
before you cleared the list because after 
you cleared the list 
Get-Command
would no longer be able to find the command.)
PS (2) > $ExecutionContext.SessionState.Applications.Clear()
Now add the path you saved in 
$ipp
to the command to the list:
PS (3) > $ExecutionContext.SessionState.Applications.Add($ipp)
And now try to run the command:
PS (4) > ipconfig | Select-String ipv4
IPv4 Address. . . . . . . . . . . : 192.168.1.15
IPv4 Address. . . . . . . . . . . : 192.168.1.5
The command works as intended—this was the point of adding its path to the list, 
after all. Now let’s try a command that isn’t on the list:
PS (5) > expand /? | Select-String expand 
The term 'expand.exe' is not recognized as the name of a cmdlet,
function, script file, or operable program. Check the spelling 
of the name, or if a path was included, verify that the path is 
correct and try again.
At line:1 char:7 
+ expand <<<<  /? | Select-String expand
+ CategoryInfo          : ObjectNotFound: 
(expand.exe:String) [], CommandNotFoundException
+ FullyQualifiedErrorId : CommandNotFoundException
You get a “command not found” error. Notice that this error doesn’t say that the com-
mand is private—the system behaves as though the command doesn't exist. It does so 
for security purposes. Now let’s attempt something that will seem a bit strange. Try 
calling the hidden command from inside a scriptblock:
PS (6) > & { expand /? | Select-String expand }
Expands one or more compressed files. 
EXPAND [-r] Source Destination
Reorder pages in pdf file - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
change page order in pdf online; how to rearrange pages in a pdf document
Reorder pages in pdf file - VB.NET PDF Page Move Library: re-order PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sort PDF Document Pages Using VB.NET Demo Code
how to move pages in pdf acrobat; how to move pages in pdf converter professional
B
UILDING
CUSTOM
REMOTING
SERVICES
541
EXPAND -r Source [Destination]
EXPAND -D Source.cab [-F:Files] 
EXPAND Source.cab -F:Files Destination
-r        Rename expanded files.
-F:Files    Name of files to expand from a .CAB.
And the command was found! So what’s going on here? Well, this is part of the con-
strained session model. Private commands are hidden from external commands—that 
is, commands that come across the session boundary, in this case, between the con-
sole host  and the PowerShell interpreter.  Scripts  and functions  (including  script-
blocks) are considered internal commands and so they can see all functions. This is 
similar to the way modules work. Only public/exported members are visible outside 
the  session/module boundary. The one big difference is that there’s a way to see 
inside the module (for debugging purposes) but there’s no way to see inside the ses-
sion once restrictions are in place. Now let’s reset the Applications list:
PS (7) > $ExecutionContext.SessionState.Applications.Clear() 
PS (8) > $ExecutionContext.SessionState.Applications.Add('*') 
PS (9) >
You now know how to use the Applications list to constrain the set of external com-
mands that may be run. This is intended to be a security measure, but as you saw ear-
lier,  if  you  can  create  a  scriptblock,  that  scriptblock  can  “bypass”  the  security 
boundary. You’ll also need to limit the ability to create functions and scriptblocks. 
You  can  do so  using the 
LanguageMode
property on 
SessionState
 Here’s  the 
default setting:
PS (2) > $ExecutionContext.SessionState.LanguageMode 
FullLanguage
The default setting is to allow all aspects of the PowerShell language to be used when 
sending commands to the engine. You’ll change this setting in a minute, but first you 
need to set up a way to undo what you’re doing. Once you’ve constrained the lan-
guage in a session, there won’t be a way to unconstrain it for that session.
NOTE
All the settings we’re looking at in this section are transient 
and only apply to the current session you’re working with. Other ses-
sions aren’t affected, nor are any new sessions that are created. So if you 
do find that you’ve broken your session by doing something out of 
order, simply exit and start a new session.
First, create a function to restore the 
LanguageMode
to 
FullLanguage
:
PS (3) > function Restore-FullLanguageMode { 
>>    $ExecutionContext.SessionState.LanguageMode = "FullLanguage" 
>> } 
>>
When you run this function, it’ll reset 
LanguageMode
to 
FullLanguage
.
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
C# TIFF - Sort TIFF File Pages Order in C#.NET. Reorder, Rearrange and Sort TIFF Document Pages in C#.NET Application. C# TIFF Page Sorting Overview.
reorder pdf pages online; move pages in a pdf file
C# PDF Page Rotate Library: rotate PDF page permanently in C#.net
C# .NET, add new PDF page, delete certain PDF page, reorder existing PDF pages and split may choose to only rotate a single page of PDF file or all
reorder pages in pdf; reordering pages in pdf
542
CHAPTER 13
R
EMOTING
CONFIGURING
APPLICATIONS
AND
SERVICES
Now change 
LanguageMode
to 
RestrictedLanguage
RestrictedLanguage
is 
the subset of the PowerShell language that’s used in PowerShell data files. We talked 
about this when we covered module manifests in chapter 10 (section 10.6):
PS (4) > $ExecutionContext.SessionState.LanguageMode = 
>> "RestrictedLanguage" 
>>
Now see how your session has been affected. First, you can’t set variables:
PS (5) > $a=123
Assignment statements are not allowed in restricted language 
mode or a Data section.
At line:1 char:4 
+ $a= <<<< 123
+ CategoryInfo          : ParserError: (=:OperatorToken) []
, ParentContainsErrorRecordException
+ FullyQualifiedErrorId : AssignmentStatementNotSupportedIn
DataSection
You also can’t create functions of any kind:
PS (6) > function foo {}
Function declarations are not allowed in restricted language 
mode or a Data section.
At line:1 char:13 
+ function foo <<<<  {}
+ CategoryInfo          : ParserError: (foo:Token) [], 
ParentContainsErrorRecordException
+ FullyQualifiedErrorId : FunctionDeclarationNotSupportedIn
DataSection
You can try to be clever and use the 
Set-Item
cmdlet as you saw in chapter 11 in sec-
tion 11.8.6:
PS (7) > Set-Item function:foo {}
Scriptblock literals are not allowed in restricted language 
mode or a Data section.
At line:1 char:25 
+ set-item function:foo {} <<<<
+ CategoryInfo          : ParserError: (:) [], 
ParentContai   nsErrorRecordException
+ FullyQualifiedErrorId : 
ScriptBlockNotSupportedInDataSection
Because you can’t perform assignments, obviously you can’t use assignment to reset 
the language:
PS (8) > $ExecutionContext.SessionState.LanguageMode = "FullLanguage" 
Assignment statements are not allowed in restricted language 
mode or a Data section.
At line:1 char:46 
+ $ExecutionContext.SessionState.LanguageMode = <<<<  
"FullLanguage"
+ CategoryInfo          : ParserError: (=:OperatorToken) []
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
Sort and Reorder PowerPoint Slides Range with VB amount of robust PPT slides/pages editing methods powerful & profession imaging controls, PDF document, image
reorder pdf pages reader; switch page order pdf
VB.NET TIFF: Modify TIFF File by Adding, Deleting & Sort TIFF
Users can use it to reorder TIFF pages in ''' &ltsummary> ''' Sort TIFF document pages in designed powerful & profession imaging controls, PDF document, image
pdf page order reverse; how to reverse page order in pdf
B
UILDING
CUSTOM
REMOTING
SERVICES
543
, ParentContainsErrorRecordException
+ FullyQualifiedErrorId : AssignmentStatementNotSupportedIn
DataSection
Use the  restore  function you  defined  before you  switched  over to 
Restricted-
Language
mode:
PS (9) > Restore-FullLanguageMode
And everything works again:
PS (10) > $a=123 
PS (11) >
Now that you know how to constrain a session, you’re halfway to your goal of being 
able to create constrained custom endpoints. In the next section, we’ll look at the sec-
ond piece: creating a custom remoting endpoint.
13.2.6
Creating a constrained execution environment
The idea behind a constrained endpoint is that it allows you to provide controlled 
access to services on a server in a secure manner. This is the mechanism that the 
hosted Exchange product Outlook.com uses to constrain who gets to manage which 
sets of mailboxes.
As mentioned earlier, for the environment to be secure, there needs to be both 
access restriction and a boundary. Remoting allows a boundary to be established as 
long as the only way to access the remote end is through the remoting layer. The 
restrictions can be established by controlling command visibility and restricting the 
language. You combine these into a custom remoting endpoint configured with a 
script that sets the configuration so that only a small subset of things is visible through 
the remoting layer. The code to accomplish this is shown in the following listing.
foreach ($cmd in Get-Command)                  
{
$cmd.Visibility = "private" 
foreach ($var in Get-Variable)    
{
$var.Visibility = "private" 
}
$ExecutionContext.SessionState.Applications.Clear() 
$ExecutionContext.SessionState.Scripts.Clear()     
$ExecutionContext.SessionState.LanguageMode = "NoLanguage" 
function Get-HealthModel  
{
@{
Date = Get-Date
Listing 13.1    Initialize-ConstrainedHMConfiguration.ps1
Hide all commands 
in session
Hide all variables 
in session
Hide all external 
programs, scripts
Set to 
NoLanguage 
mode
Define public 
Get-HealthModel
C# PDF: C# Code to Process PDF Document Page Using C#.NET PDF
delete or remove certain page from PDF document file. C# PDF Page Processing: Sort PDF Pages - online C#.NET tutorial page for how to reorder, sort, reorganize
how to reorder pdf pages in; rearrange pdf pages in reader
Read PDF in Web Image Viewer| Online Tutorials
for image viewing to read, edit, create or write PDF documents from file or stream in Extract images from PDF documents; Add, reorder pages in PDF
rearrange pages in pdf document; move pdf pages online
544
CHAPTER 13
R
EMOTING
CONFIGURING
APPLICATIONS
AND
SERVICES
FreeSpace = (Get-PSDrive c).Free
PageFaults = (Get-WmiObject `
Win32_PerfRawData_PerfOS_Memory).PageFaultsPersec
TopCPU = Get-Process | sort -Descending CPU  | select -First 5
TopWS = Get-Process | sort -Descending WS | select -First 5
}
The first part of this script is generic and reusable. It can be used as a preamble to any 
constrained endpoint configuration script. Any function defined after the line setting 
the session to 
NoLanguage
mode will be publicly visible and represents the services 
this endpoint provides.
NOTE
When some people first looked at the example in listing 13.1 
they thought there was a bug because some statements are executed 
after the language mode is set. This isn’t the case for two reasons: First, 
because this is an endpoint configuration script, it’s executed inside the 
session boundary where the restrictions don’t apply. Second, a Power-
Shell script is completely parsed before execution begins so all language 
processing  for this  script was completed  before  the language mode 
change was made, and language mode checks are only done during 
parse time.
In this example, you’re adapting the health model function you saw in chapter 12, 
section 12.2.3, to be run in this endpoint. Try this script. From an elevated Power-
Shell session, run the following commands:
PS (1) > Unregister-PSSessionConfiguration -Name wpia1 -Force 
PS (2) > Register-PSSessionConfiguration -Name wpia1 ` 
>>     -StartupScript $pwd/Initialize-ConstrainedHMConfiguration.ps1 ` 
>>     -Force 
>>
WSManConfig: Microsoft.WSMan.Management\WSMan::localhost\Plugin
Name                      Type                 Keys 
----                      ----                 ----
wpia1                     Container            {Name=wpia1}
The first command removes the existing endpoint definition in case it may be left 
from an earlier operation. The second line creates the new endpoint with the script 
from listing 13.1. With the endpoint installed, you can try it. Run the 
Get-Health-
Model
command:
PS (3) > icm localhost -ConfigurationName wpia1 {Get-HealthModel}
Name                           Value 
----                           -----
Date                           2/24/2010 11:32:49 PM 
TopWS                          {System.Diagnostics.Process (svchos... 
PageFaults                     63217485
VB.NET TIFF: VB.NET Sample Code to Process & Manage TIFF Page
certain TIFF page, and sort & reorder TIFF pages in Process TIFF Pages Independently in VB.NET Code. powerful & profession imaging controls, PDF document, image
rearrange pdf pages in preview; change page order in pdf file
C# Word: How to Create Word Document Viewer in C#.NET Imaging
in C#.NET; Offer mature Word file page manipulation functions (add, delete & reorder pages) in document viewer; Rich options to add
reorder pdf page; how to reorder pages in pdf
B
UILDING
CUSTOM
REMOTING
SERVICES
545
TopCPU                         {System.Diagnostics.Process (svchos... 
FreeSpace                      362546515968
It executes properly. Try another command:
PS (4) > Invoke-Command localhost -ConfigurationName wpia1 {Get-Date}
The term 'Get-Date' is not recognized as the name of a cmdlet, 
function, script file, or operable program. Check the spelling of the name,
or if a path was included, verify that the path is correct and try 
again.
+ CategoryInfo          : ObjectNotFound: (Get-Date:String) [],
CommandNotFoundException
+ FullyQualifiedErrorId : CommandNotFoundException
This code fails with the expected error. Try using 
Get-Command
to see the list of the 
things you can execute:
PS (5) > Invoke-Command localhost -ConfigurationName wpia1 {Get-Command} 
The term 'Get-Command' is not recognized as the name of a cmdlet, 
function, script file, or operable program. Check the spelling of the 
name, or if a path was included, verify that the path is correct and 
try again.
+ CategoryInfo          : ObjectNotFound: (Get-Command:String) [
], CommandNotFoundException
+ FullyQualifiedErrorId : CommandNotFoundException
This code also fails—not unexpected, but it’d be nice to see what’s exposed. Try inter-
active remoting:
PS (6) > Enter-PSSession localhost -ConfigurationName wpia1 
Enter-PSSession : The term 'Get-Command' is not recognized as the 
name of a cmdlet, function, script file, or operable program. Check the 
spelling of the name, or if a path was included, verify that the path
is correct and try again.
At line:1 char:16 
+ Enter-PSSession <<<<  localhost -ConfigurationName wpia1
+ CategoryInfo          : ObjectNotFound: (Get-Command:String) [
Enter-PSSession], CommandNotFoundException
+ FullyQualifiedErrorId : CommandNotFoundException
This code also fails because an interactive session requires certain commands to be 
available on the remote end, like the default outputter commands we discussed earlier. 
Let’s move on to implicit remoting. Where interactive remoting isn’t likely to be very 
interesting with only one command, the constrained endpoint is the ideal scenario for 
implicit remoting:
PS (8) > $s = New-PSSession localhost -ConfigurationName wpia1 
PS (9) > Import-PSSession $s -Verbose 
Import-PSSession : Import-PSSession cmdlet needs the following 
commands in the remote session: Get-Command, Get-FormatData, Select-Object.
The following commands are used, but optional: Get-Help, 
Measure-Object.  Please make sure the remote session includes the required 
commands and try again.
At line:1 char:17 
+ Import-PSSession <<<< $s -Verbose
546
CHAPTER 13
R
EMOTING
CONFIGURING
APPLICATIONS
AND
SERVICES
+ CategoryInfo          : ObjectNotFound: (:) [Import-PSSession]
, RuntimeException
+ FullyQualifiedErrorId : ErrorRequiredRemoteCommandNotFound,Mic
rosoft.PowerShell.Commands.ImportPSSessionCommand 
PS (10) > 
This code also fails for the same reason. For implicit remoting to work, it needs to be 
able to get the information about the commands in the remote session. From the 
error message for the 
Import-PSSession
case, you can see the list of commands that 
need to be present. You could create a script to handle this, but there’s a feature in the 
PowerShell 
API
that was specifically designed to address this case. There’s a .
NET
class 
that’s part of the PowerShell software development kit 
(SDK)
that’s intended to be 
used by programmers who are writing custom hosts for the PowerShell engine. This 
class is used to create the initial settings for a session used in different applications. 
This class is called 
InitialSessionState
and you can use it as follows:
$iss = [Management.Automation.Runspaces.InitialSessionState]::
CreateRestricted(
"remoteserver")
This creates an object that contains the settings needed for building a constrained 
environment intended for a 
remoteserver 
application. You don’t need all the set-
tings that this object contains, but it does have something very useful in it: a set of 
function definitions that fulfill the needs of both interactive and implicit remoting. 
You can see this list by running this code:
PS (1) > $iss = 
>> [Management.Automation.Runspaces.InitialSessionState]::CreateRestricted( 
>> "RemoteServer") 
>>
PS (2) > $iss.Commands | where { $_.Visibility -eq "Public" } | 
>> Format-Table name 
>>
Name 
----
Get-Command 
Get-FormatData 
Select-Object 
Get-Help 
Measure-Object 
Exit-PSSession 
Out-Default
The bodies of these functions are similar to the proxy functions used for implicit 
remoting that you saw in chapter 12, section 12.4.2. 
NOTE
When you look at this list of commands, you may wonder why 
some of them are included. For example, 
Measure-Object
seems like 
a strange thing to have on the list. The reason these commands are 
included is that they’re needed to implement some of the elements of
B
UILDING
CUSTOM
REMOTING
SERVICES
547
the PowerShell remoting protocol. In particular, they’re used to help 
with the command-discovery component described in 
MS-PSRP
sec-
tion 3.1.4.5, “Getting Command Metadata.”
The goal here is a bit different because they’re used to provide public facades for pri-
vate commands. If you’re interested in how these functions are defined, look at the 
Definition
property on the objects returned by 
Commands
by using the following 
code:
PS (3) > $p = $iss.Commands | where { $_.Visibility -eq "Public" } 
PS (4) > $p[0] | Format-List name,definition 
Name       : Get-Command 
Definition : [CmdletBinding()]
param(
[ValidateLength(0, 1000)]
[ValidateCount(0, 1000)]
[System.String[]]
${Name},
[ValidateLength(0, 1000)]
[ValidateCount(0, 100)]
[System.String[]]
${Module}, 
:
The output is truncated here because it’s quite long. (Again, be happy you don’t have 
to write these functions—you’re welcome to explore them at your leisure but we’re 
not going to spend any more time looking at them.) Once you have this object, you 
can copy these functions into your session:
foreach ($cmd in $iss.Commands | where { $_.Visibility -eq "Public"}) 
{
$needsAlias = Get-Command -CommandType Cmdlet `
-ErrorAction SilentlyContinue $cmd.Name
if ($needsAlias)
{
$a = Set-Alias $cmd.Name "$($needsAlias.ModuleName)\$($cmd.Name)" `
-PassThru 
$a.Visibility = "Private" 
}
Set-Item "function:global:$($cmd.Name)" $cmd.Definition 
}
This code fragment loops through the set of command definitions, looking for the 
public definitions, and then uses the function provider to define new public func-
tions in the session. It also defines some new private aliases that are used to bypass the 
proxies for internal calls. This step is necessary because some of the public functions 
you want to write may use the some of the cmdlets you’ve just proxied. Because the 
proxies don’t implement all the features of the wrapped cmdlets, not being able to
548
CHAPTER 13
R
EMOTING
CONFIGURING
APPLICATIONS
AND
SERVICES
access to the un-proxied commands could interfere with the operation of any new 
commands you want to write.
Using aliases to bypass the proxies works because of the way command resolution 
operates. Remember that, when you’re looking for a command, you look for aliases 
first, then functions, and then cmdlets. This order is always followed when the call is 
coming from inside the session. If the call is coming from outside the session, the 
lookup order doesn’t change, but if one of the things it finds is private, that defini-
tion is skipped and the lookup moves on to the next type of command. So, if you 
define an alias that uses the module-qualified name of a cmdlet, internal lookups will 
resolve to the alias. This alias uses module-qualified name for the cmdlet, thereby 
skipping the function and going directly to the cmdlet. External lookups, on the 
other hand, won’t see the alias because it’s private. They can only see the public con-
strained proxy function. These lookup patterns are shown in figure 13.11.
Now let’s see how all this looks when you add these code fragments to your con-
figuration script. The following listing shows the updated configuration script.
foreach ($cmd in Get-Command)                
                                         
$cmd.Visibility = "private"      
                                          
foreach ($var in Get-Variable)               
                                              
$var.Visibility = "private"           
                                                
$ExecutionContext.SessionState.Applications.Clear()  
$ExecutionContext.SessionState.Scripts.Clear()    
Get-HealthModel
Aliases, proxies, and cmdlets in constrained sessions
Select-Object
Select-Object proxy function 
(visibility: public)
Get-HealthModel function 
(visibility: public)
Constrained PSSession
Select-Object alias 
(visibility: private)
Select-Object cmdlet 
(visibility: private)
Session 
boundary
Figure 13.11 The call flow 
from the public constrained 
Select-Object
proxy 
function to the private uncon-
strained 
Select-Object
cmdlet. When the user calls 
the public 
Get-
HealthModel
and it calls 
Select-Object
, the call re-
solves to the private 
Select-Object
alias. This 
alias is hard-coded to bypass 
the constrained proxy func-
tion and call the cmdlet di-
rectly giving unconstrained 
access internally.
Listing13.2    Initialize-ComplexConstrainedHMConfiguration.ps1
Hide existing 
commands
B
UILDING
CUSTOM
REMOTING
SERVICES
549
ExecutionContext.SessionState.LanguageMode =         
"NoLanguage" 
$iss =                      
[Management.Automation.Runspaces.InitialSessionState]::CreateRestricted(
"remoteserver") 
foreach ($proxy in $iss.Commands | where { $_.Visibility -eq "Public"}) 
  
$cmd = Get-Command -type cmdlet -ea silentlycontinue $proxy.name
if ($cmd)
{
$a = Set-Alias "$($proxy.name)" `
"$($cmd.ModuleName)\$($cmd.Name)" -PassThru   
$a.Visibility = "Private" 
}
Set-Item "function:global:$($proxy.Name)" `
$proxy.Definition 
function Get-HealthModel               
{
@{
Date = Get-Date
FreeSpace = (Get-PSDrive c).Free
PageFaults = (Get-WmiObject `
Win32_PerfRawData_PerfOS_Memory).PageFaultsPersec
TopCPU = Get-Process | sort -Descending CPU | select -First 5
TopWS = Get-Process | sort -Descending WS | select -First 5
}
This script is identical to the earlier script with the exception that it has the additional 
lines needed to define the proxy functions. Let’s test this out. First, re-create the end-
point using the new configuration script:
PS (1) > Unregister-PSSessionConfiguration -Name wpia1 -Force 
PS (2) > Register-PSSessionConfiguration -Name wpia1 -StartupScript ` 
>> $pwd/Initialize-ComplexConstrainedHMConfiguration.ps1.ps1 -Force 
>>
WSManConfig: Microsoft.WSMan.Management\WSMan::localhost\Plugin
Name                      Type                 Keys 
----                      ----                 ----
wpia1                     Container            {Name=wpia1}
NOTE
In practice, you wouldn’t normally bother to re-create the end-
point because the script is actually loaded and run each time a session 
starts. It’s sufficient to simply edit the script and then start a new con-
nection to test your changes (existing connections will remain unaf-
fected).
Start an interactive remoting session with this new configuration:
PS (3) > Enter-PSSession localhost -ConfigurationName wpia1
Set NoLanguage 
mode
Get list of required proxies
Bind private
alias and proxy 
function
Define public 
content
Documents you may be interested
Documents you may be interested