If you are processing a faxed application, and a date of death is present for the responsible party, fax the Form SS-4 back to the sender using the campus cover sheet. If the Form SS-4 was faxed by the responsible party, use the following language: "We are sorry, but we are unable to provide you with an EIN at this time. Our records show a date of death is present. Contact the Social Security Administration (SSA) to correct the information. Then, you must mail or fax us a completed and signed Form SS-4, along with the documentation received from SSA as verification. Upon receipt, the application and documentation will be evaluated, and, if complete, an EIN will be faxed back within 4 business days." If the Form SS-4 was faxed by a TPD/POA or other authorized individual, use the following language: "We are sorry, but we are unable to provide you with an EIN at this time. Please have the responsible party contact us." See IRM 10.5.1.6.9.4, Faxing for guidance.
If you are processing a mailed application, and a date of death is present for the responsible party, mail the Form SS-4 back to the sender using Notice Gatekeeper Web (SNIP) - LTR 0045C Detail Page (irs.gov) , EIN Application Requested/Received (Form SS-4). Use paragraphs G and open paragraphs 0 (zero) and *(asterisk). If the Form SS-4 was received from the responsible party, in the open paragraphs, provide the following language: "We are sorry, but we are unable to provide you with an EIN at this time. Our records show a date of death is present. Contact the Social Security Administration (SSA) to correct the information. Then, you must mail or fax us a completed and signed Form SS-4, along with the documentation received from SSA as verification. Upon receipt, the application and documentation will be evaluated, and, if complete, an EIN will be assigned and a notice will be sent to you." If the Form SS-4 was received from a TPD/POA or other authorized individual, in the open paragraphs, provide the following language: "We are sorry, but we are unable to provide you with an EIN at this time. Please have the responsible party contact us."
Atomic Mail Sender Serial Crack 14
[ Top ]Counter: A Simple ExampleSuppose you have a Counter class withan object named foo . This object contains a number, which programmerscan increment and query using the methods bump and value. An object like this could help clients to generate serial numbers forprocesses, orders, transactions, etc. Programmers can create the objecton the server and make it available to clients with the following code:package require Iserverclass Counter inherit ::iserver::Distributed method bump return [incr count] method value return $count private variable count 0Counter foo::iserver::listen 8066The server begins by initializingthe Iserver package , thereby creating commands and base classesthat the server needs. It then defines an [incr Tcl] class Counterwith two methods bump and value . By inheriting from theDistributed class, the Counter class is able to share itsobjects with clients. The server creates a Counter object calledfoo , and then opens a socket on port 8066 and waits for clientsto connect and start using foo .Now suppose there are two clients that wouldlike to use the server's foo object. Each client needs to load theIclient package, and then connect to the server. It does so by creatinga Server object, and telling it to connect to the server listeningat port 8066 on the machine sercial.micro.lucent.com:package require Iclientset serv [::iclient::Server #auto sercial.micro.lucent.com 8066]$serv resolve class Counter$serv resolve object foofoo bumpNow that the client is connectedto the object server, it can attach itself to the Counter foo .To do this, the client resolves the names of both the class, Counter, and the object, foo . In other words, the client has gone to theserver and created its own, local copy of Counter and foo, which it can use to access the actual, server entities of the same names.All the client needs to do is call the bump method on its object,and Iclient will take care of running bump on the server objectfoo .The local copy of foois merely a client-side stub. Methods are not truly implemented on theclient side; instead, the client methods serve as an interface for callingcorresponding methods on the server object foo . A client stub canalso be considered conceptually as a local, client-based, reference toa server object.Now imagine that the clientswant to use the Counter foo in a simple GUI. A label will storethe current value of foo , and a button will allow the client tobump the value of foo . If one client changes the value offoo , the GUI of the other client should update to show the newvalue as well....button .bump -text "Bump" -command foo lock .count configure -text [foo bump] pack .bump -side left -padx 6 -pady 10label .count -text [foo value]pack .count -side left -padx 6 -pady 10foo watch lock .count configure -text [foo value]This example uses two objectservices of Iclient/Iserver: lock and watch. When pressed,the button .bump requests a lock on foo . It then incrementsits value by calling the bump method. Interprocess communicationpresents a host of concurrency problems that occur when two clients tryto manipulate the same resource at the same time. In Iclient/Iserver, mostmethod calls will be atomic, unless they access the event loop. To be certainof exclusive access to a server object, a client should request a lockwhenever modifying a server object.Locks are especially helpfulwhen a client needs to manipulate a server object with multiple methodcalls, where the entire series of operations needs to run atomically. Byacquiring a lock on a server object, a client gains exclusive control ofthat object.In a slightly more complicatedscenario, clients may be using the Counter object to keep trackof the current bid price in an auction. Clients will check the currentprice, and if it falls below maxBid , they will bid by incrementingthe Counter foo .if [foo value] maxBid for each client. The object server processesclient requests in the order they are received. If both clients check thevalue of foo , they will both receive the same value and decideto bump the Counter . When this occurs, one of the clientswill exceed their maximum bid, because the state of foo will havechanged between the time the client checked its value, and the time ittries to bump the foo .Locks solve this problem nicelyby allowing each client to check foo and bump its value withoutinterruption from the other client. immediately:foo lock if [foo value] foo , it is the onlyclient allowed to access foo until the lock is removed. If anotherclient tries to access foo while the first holds the lock, it willhave to wait until the lock is released.By default, clients will tenseconds for the lock; if that time expires, the lock method raisesa Tcl error. Clients can adjust the timeout factor by providing a value,in milliseconds, for the -timeout option of the lock method.A timeout of zero indicates that the client should give up waitingif it cannot obtain the lock. If the client may need to wait for a noticeableperiod to obtain a lock, it will likely wish to display a watch cursor,or some other GUI indication that the client is busy. The lock methodprovides two more options, -suspend and -continue to allowthe client to run a script immediately before waiting for the lock, andimmediately after the lock is obtained. The Counter clients mayuse this to display a message in the label .count as they wait forthe lock:foo lock .count configure -text [foo bump] -timeout 20000 -suspend .count configure -text "Acquiring lock" -continue .count configure -text "Lock acquired"One more detail remains tobe explained: when one client bumps the value of foo , the otherclients need to know that foo has changed in order to update theirdisplays. Clients can watch objects, and register a callback thatwill run when a particular event occurs to the object. This is similarto a variable trace or to a binding on a Tk widget. Keeping track of anobject being locked is rather straightforward. The clients can watchfor foo to be locked; when that occurs, they know that foohas changed, and they can call the value method to learn the newvalue of the Counter . Clients can watch any object, lookingfor well-defined or custom-defined events to occur. Well-known events includelock , destroy , and resolve . Distributedobjects can report custom events by using the report method, asin the following:class Counter inherit ::iserver::Distributed method bump report "bump" return [incr count] ...The last services that Iclient/Iserverprovide are the ability to restrict use of a server object to a subsetof connected clients. An object server gives each of its clients an uniqueid, and can use this id with the Distributed class's restrictmethod. Here a server restricts use of the object foo to a single clientwith client id client1 :foo restrict client1[ Top ]ArchitectureApplications written using Iclient/Iserver areconstructed with a client/server architecture where the server programprovides central services for the client programs connected by a network.The server helps the clients to interact by holding shared informationand synchronizing the clients' access to this information.In any client/server architecture, an APImediates between clients and server services. In the remote procedure call(RPC) approach, the server program publishes a set of commands that clientsuse to communicate with the server. An RPC approach works well for proceduralapplications, such as vanilla Tcl scripts, where command provide the onlyinterface for performing operations.An [incr Tcl] script uses classesto encapsulate data and related commands into a single entity. Each classhas a well-defined set of methods that act as the interface for workingwith objects of that class. By invoking these methods, it is possible toaccess and manipulate the data contained by the object.Turning an [incr Tcl] scriptinto a client/server application should be a process that keeps the interfacesdefined by the classes intact. A RPC approach does not work well with [incrTcl] scripts because it requires wrapping each method with a procedure.there to be a procedural wrapper for accessing the methods of an object.Adding a procedural communication mechanism to an object-oriented designbreaks up the design of classes. At best, it is inelegant. At worst, itis tedious to set up and confuses the interface created by the class methods.It would be much better to allow clients to access server objects in themanner that the server manipulates its object: by calling the methods definedfor the object.That is the goal of Iclient/Iserver.The server uses [incr Tcl] to create classes and objects with well-definedinterfaces. Iserver provides a base class, Distributed , that publishesderived classes and their objects, so that clients connecting to the servercan use those objects across a network socket.Iclient provides the clientaccess to server objects by creating local copies, or stubs, which actas references to the server objects. When a client access a client stub,the stub encapsulates the server communication required to access thecorrespondingserver object.It is possible for a clientto be connected simultaneously with multiple object servers. Iclient providesa class Server to help client scripts to keep track of a given objectserver connection. When a client wants to connect to a new object server,it creates a new instance of this Server class and feeds it informationabout the hostname and port number of the object server. The methods ofthe Server class provide a secondary API that clients use to accessan object server, to create client stubs, create new server objects, destroyserver objects, and inquire about objects available on the server. Iclient and Iserver are currently implementedas Tcl scripts that rely upon [incr Tcl] to provide classes and objects.The first alpha of Iclient/Iserver used [incr Tcl]'s namespace facility,but the revised version uses [incr Tcl] 3.0 and Tcl 8.0 namespaces. Iclientand Iserver use namespaces to encapsulate the classes and commands thatthey introduce.[ Top ]Distributed Object ModelThis section describes in detail how the Iclient/Iserverdistributed object model works. It covers the two ways clients can createclient stubs for server objects. It discusses the underlying commands andclasses that the stubs use to communicate with the server. It also describeshow sockets, fileevents, and safe interpreters form the primitive communicationframework.The central task for Iclient/Iserver is toallow clients to access server objects in a manner consistent with accessingordinary [incr Tcl] objects in a stand-alone application. To do this, aserver object must appear as if it lived locally, on the client. It mustalso have the same methods as the server object, and the client must beable to call those methods as with ordinary [incr Tcl] objects.To accomplish this, Iclient/Iserver literallycreates a client-side object to act as a stub for the server object theclient would like to use. These stubs are [incr Tcl] objects; therefore,the client requires a class declaration to produce the stub. The Serverclass that servers as an API to access an object server provides a methodresolve that resolves the binding between the client stub and theserver object.Iclient/Iserver provides both implicit andexplicit mechanisms for resolving references to server objects. In theimplicit model, the client code does nothing to resolve references to serverobjects. The client merely connects to an object server, and starts usingwell-known objects. To return to the Counter example, suppose aclient runs the following code:package require Iclientset serv [iclient::Server #auto sercial.micro.lucent.com 8066]foo bumpThe client has connected toan object server but has done nothing to link the server object footo the client. The client proceeds anyway, calling the bump methodof foo . The Tcl parser looks for a command named foo butcannot find one defined. Ordinarily, the parser would raise an error sayingthat the command foo does not exist. But Iclient has changed theway Tcl handles unknown commands by introducing its own handler into thebuilt-in unknown command.This handler knows about theobject servers that the client is attached to, and it asks each objectserver if it can identify the name foo .$server ask identify fooThe ask command isa primitive to Iclient and Iserver that allows a process to send a Tclcommand to another process and wait for the result. In this case, the clientsends the script "identify foo " to the server, who will evaluatethe identify command. This command looks to see if foo iseither the name of a distributed class or a distributed object on the server.The server determines that foo is an object, and sends a reply tobe evaluated in the client:respond 1 0 "object Counter"The respond command is usedto tell the client that the server has a formulated a response to one ofits ask requests. It reads the return code and the return valuefrom the server, and learns that foo is an object of classCounter . The client knows that foo is a Counter object,and tries to create it on the client side:Counter fooUnfortunately, the clienthas also never seen the command Counter before. The unknowncommand runs again, this time looking for Counter , and asks theserver if it knows of a name Counter:$serv ask identify CounterThis time the server repliesthat Counter is a class. The client asks the server to supply aclass stub for the Counter class:$serv resolve class CounterCounter fooThe server must now generatea stub for the class Counter , and pass the stub for the clientto use. This involves creating a new class declaration that has only thepublic methods of Counter . These stub methods are not implementedas they are in the client class declaration; instead, each is a wrapperaround an interface that runs the same method on the server object. Thestub class declaration created for the Counter class might looklike this:class Counter method bump args return [eval $server ask object invoke [namespace tail $this] bump $args] method value args return [eval $server ask object invoke [namespace tail $this] value $args] ...Now the client has a stubfor the Counter class. It can now try to resolve a reference tofoo .$serv resolve object fooThe client asks the serverto help it resolve a reference to foo. This causes the client to createa client stub called foo using the class declaration previouslygenerated by the server. With the stub in place, the client can now invokemethods on the stub; when it does so, the stub will ask the server to invokeits own object named foo and will use the response from the serveras its return value.This rather detailed chain of events is illustratedin the figure below. What is important to realize is that all this detailwas handled by the Iclient package; the client script set this intomotion by the innocent looking call of foo bump . The entire processof resolving is transparent to the programmer, who needed only to createan object on the server, and use that object on the client.The advantage to this systemis that the client code does not have to declare server classes or objectsexplicitly before using them. Iclient performs late binding to the serverobjects, doing it only when necessary, and handles all the details of classand object stub generation. But implicit resolving requires Iclient tosearch through all the object servers connected to a client--usually thisrepresents only a single server, but that does not have to be the case.Tosolve these problems, Iclient also offers an explicit interface for generatingclient stubs. A client can request a stub from a Server object,by calling that object's resolve method. 2ff7e9595c
Comments