SQL Object dependency identification

Problem:
Is there a way to identify which objects are dependent on other objects within a SQL Server database? I need to modify the table structure to add new columns. However, before making any changes I want to make sure that I understand all the object dependencies. Is there a way in SQL Server 2008 to quickly identify all the object dependencies?

Solution
In the earlier versions of SQL Server object dependencies were tracked using the ID of the object, as a result it was tough to keep track of Object Dependencies. However, in SQL Server 2008 Objects are tracked using the name of the object rather than object IDs. The biggest advantage of this approach is that you can track object dependency even after the object is removed from the database and you can also track even if an object is yet to be created in the database.

In SQL Server 2008 there are two new Dynamic Management Functions and a System View introduced to keep track of Object Dependencies. The newly introduced Dynamic Management Functions in SQL Server 2008 to keep track of object dependencies are sys.dm_sql_referenced_entities and sys.dm_sql_referencing_entities.  The newly introduced system view to keep track of object dependency is sys.sql_expression_dependencies.

The sys.sql_expression_dependencies system view holds one record each for a user defined object which has dependency on other object within the current database. A dependency between two objects is created when one object calling the referenced object appears by name in a SQL expression of another object. There are basically two types of dependencies tracked by the database engine in SQL Server 2008 namely Schema-bound Dependency and Non-schema-bound Dependency.

• Schema-bound dependency: - A schema-bound dependency is a relationship that exists between two objects that prevents referenced objects from being dropped or modified as long as the referencing object exists. A quick example of schema-bound dependency will be a view or a user defined function which is created using WITH SCHEMABINDING clause.
• Non-schema-bound dependency: - A non-schema-bound dependency is a relationship which exists between two objects which doesn’t prevent the referenced object from being dropped or modified.

The sys.dm_sql_referenced_entities Dynamic Management Function returns one row for each user defined object which is referenced by name within the definition of a specified referencing object. For example, if a user defined view is the specified referencing object, then by using sys.dm_sql_referenced_entities dynamic management function you can return all the user defined objects that are referred in the view definition such as tables, functions etc.

 

The sys.dm_sql_referencing_entities Dynamic Management Function returns one record for each user defined object within the current database which refers to another user defined object by name. For example, if there is a view which refers to three tables then this function will return three records one for each table reference. This function will also return dependency information for Schema-bound or Non-schema-bound entries, Database level and Server level DDL triggers.

 

 

 

Example:

 

/* Find all object which are referencing to <OBJECT_NAME> OBJECT */

SELECT

referencing_schema_name +'.'+ referencing_entity_name AS ReferencedEntityName,

referencing_class_desc AS ReferencingEntityDescription

FROM sys.dm_sql_referencing_entities (<OBJECT_NAME>, 'OBJECT');

GO

 

/* Find all object which are referenced by <OBJECT_NAME> OBJECT */

SELECT

referenced_schema_name +'.'+ referenced_entity_name AS ReferencedEntityName,

referenced_minor_name AS ReferencedMinorName

FROM sys.dm_sql_referenced_entities (<OBJECT_NAME>, 'OBJECT');

GO

 

/* Identifying Object Dependencies */

SELECT

SCHEMA_NAME(O.SCHEMA_ID) +'.'+ o.name AS ReferencingObject,

SED.referenced_schema_name +'.'+SED.referenced_entity_name AS ReferencedObject

FROM sys.all_objects O INNER JOIN sys.sql_expression_dependencies SED

ON O.OBJECT_ID=SED.REFERENCING_ID

WHERE O.name = <OBJECT_NAME>

GO

 

Profile Vs Session [ASP.NET]

Comparing Profile[HttpContext.Current.Profile] and Session[HttpContext.Current.Session]:

 

1) Both objects store separate data for each user of your web application without the developer having to

worry about coding for such.

2) Session often needs a small timeout value to protect the user enough, while Profile only ends at the

developer's discretion.

3) Profile allows control over clearing by inactive profiles versus active ones, time periods, etc., while

session is one or all.

4) Profile is strongly typed and Session is not.

5) At runtime, a key can be added to Session, a property for Profile must be designed in before runtime.

6) Session must load the entire dictionary to read only one value, while Profile can read just one property

efficiently (more scalable).

7) Both can store any kind of object.

 

 

use the Profile tab of the Web Site Administration Tool (WAT) to manage how your site collects personal

information about visitors. Profile properties represent data specific to a particular user. Using profile

properties enables you to personalize your Web site for individual users. The address for this web application

will be: http://localhost/AppFolderNameInWebsites/Webadmin.axd

 

Abstract Factory Vs Builder

The abstract factory pattern is a software design pattern that provides a way to encapsulate a group of individual factories that have a common theme. In normal usage, the client software creates a concrete implementation of the abstract factory and then uses the generic interfaces to create the concrete objects that are part of the theme. The client does not know (or care) which concrete objects it gets from each of these internal factories since it uses only the generic interfaces of their products. This pattern separates the details of implementation of a set of objects from their general usage.

An example of this would be an abstract factory class DocumentCreator that provides interfaces to create a number of products (e.g. createLetter() and createResume()). The system would have any number of derived concrete versions of the DocumentCreator class like FancyDocumentCreator or ModernDocumentCreator, each with a different implementation of createLetter() and createResume() that would create a corresponding object like FancyLetter or ModernResume. Each of these products is derived from a simple abstract class like Letter or Resume of which the client is aware. The client code would get an appropriate instance of the DocumentCreator and call its factory methods. Each of the resulting objects would be created from the same DocumentCreator implementation and would share a common theme (they would all be fancy or modern objects). The client would need to know how to handle only the abstract Letter or Resume class, not the specific version that it got from the concrete factory.

In software development, a Factory is the location in the code at which objects are constructed. The intent in employing the pattern is to insulate the creation of objects from their usage. This allows for new derived types to be introduced with no change to the code that uses the base class.

Use of this pattern makes it possible to interchange concrete classes without changing the code that uses them, even at runtime. However, employment of this pattern, as with similar design patterns, may result in unnecessary complexity and extra work in the initial writing of code. Used correctly the "extra work" pays off in the second instance of using the Factory.

 

 

The builder pattern is a software design pattern. The intention is to abstract steps of construction of objects so that different implementations of these steps can construct different representations of objects. Often, the builder pattern is used to build products in accordance to the composite pattern, a structural pattern.

        Builder

Abstract interface for creating objects (product).

Concrete Builder

Provides implementation for Builder. It is an object able to construct other objects. Constructs and assembles parts to build the objects.

        Director

The Director class is responsible for managing the correct sequence of object creation. It receives a Concrete Builder as a parameter and executes the necessary operations on it.

        Product

The final object that will be created by the Director using Builder.

• Builder focuses on constructing a complex object step by step. Abstract Factory emphasizes a family of product objects (either simple or complex). Builder returns the product as a final step, but as far as the Abstract Factory is concerned, the product gets returned immediately.
• Builder often builds a Composite.
• Often, designs start out using Factory Method (less complicated, more customizable, subclasses proliferate) and evolve toward Abstract Factory, Prototype, or Builder (more flexible, more complex) as the designer discovers where more flexibility is needed.
• Sometimes creational patterns are complementary: Builder can use one of the other patterns to implement which components are built. Abstract Factory, Builder, and Prototype can use Singleton in their implementations.

 

 

 

 

Diff b/w Factory & Builder

 

The factor pattern defers the choice of what concrete type of object to 

make until run time. E.g. going to a restaurant to order the special of 
the day.  The waiter is the interface to the factory that takes the 
abstractor generic message "Get me the special of the day!" and returns 
the concrete product (i.e Liver souffle or Chicken caramel) 

The builder pattern encapsulates the logic of how to put together a 
complex object so that the client just requests a configuration and the 
builder directs the logic of building it.   E.g The main contractor 
(builder) in building a house knows, given a floor plan, knows how to 
execute the sequence of operations (i,e. by delegating to subcontractors) 
needed to build the complex object.  If that logic was not encapsulated in 
a builder, then the buyers would have to organize the subcontracting 
themselves ("Dear, shouldn't we have asked for the foundation to be laid 
before the roofers showed up?") 

The factory is concerned with what is made, the builder with how it is 
made.  Design patterns points out that (page 105) Abstract factory is 
similar to builder in that it too may construct complex objects.  The 
primary difference is that the Builder pattern focuses on constructing a 
complex object step by step.  Abstract factor's emphasis is on families of 
product objects(either simple or complex).  Builder returns the product as 
the final step, but as far as the Abstract Factory is concerned, the 
product gets returned immediately 

 

 

Windows Powershell??

Starting looking at windows powershell scripting and its effective use. Came across a very usefull site for powershell scripts.

Will be exploring it in details as it looks like a long term core windows tool.

 

Below is a very detailed and usefull script which can be easily converted to a C# example :D

 

 

Powershell Script[.ps1] to Capture Screeshot

 

 

Function Take-ScreenShot {

    <# 

.SYNOPSIS 

    Used to take a screenshot of the desktop or the active window.

.DESCRIPTION 

    Used to take a screenshot of the desktop or the active window and save to an image file if needed.

.PARAMETER screen

    Screenshot of the entire screen

.PARAMETER activewindow

    Screenshot of the active window

.PARAMETER file

    Name of the file to save as. Default is image.bmp

.PARAMETER imagetype

    Type of image being saved. Can use JPEG,BMP,PNG. Default is bitmap(bmp)   

.INPUTS

.OUTPUTS   

.NOTES 

    Name: Take-ScreenShot

    Author: Boe Prox

    DateCreated: 07/25/2010    

.EXAMPLE 

    Take-ScreenShot -activewindow

    Takes a screen shot of the active window       

.EXAMPLE 

    Take-ScreenShot -Screen

    Takes a screenshot of the entire desktop

.EXAMPLE 

    Take-ScreenShot -activewindow -file "C:\image.bmp" -imagetype bmp

    Takes a screenshot of the active window and saves the file named image.bmp with the image being bitmap

.EXAMPLE 

    Take-ScreenShot -screen -file "C:\image.png" -imagetype png   

    Takes a screenshot of the entire desktop and saves the file named image.png with the image being png

#> 

#Requires -Version 2

        [cmdletbinding(

                SupportsShouldProcess = $True,

                DefaultParameterSetName = "screen",

                ConfirmImpact = "low"

        )]

Param (

       [Parameter(

            Mandatory = $False,

            ParameterSetName = "screen",

            ValueFromPipeline = $True)]

            [switch]$screen,

       [Parameter(

            Mandatory = $False,

            ParameterSetName = "window",

            ValueFromPipeline = $False)]

            [switch]$activewindow,

       [Parameter(

            Mandatory = $False,

            ParameterSetName = "",

            ValueFromPipeline = $False)]

            [string]$file,

       [Parameter(

            Mandatory = $False,

            ParameterSetName = "",

            ValueFromPipeline = $False)]

            [string]

            [ValidateSet("bmp","jpeg","png")]

            $imagetype = "bmp"          

 

)

# C# code

$code = @'

using System;

using System.Runtime.InteropServices;

using System.Drawing;

using System.Drawing.Imaging;

namespace ScreenShotDemo

{

  /// <summary>

  /// Provides functions to capture the entire screen, or a particular window, and save it to a file.

  /// </summary>

  public class ScreenCapture

  {

    /// <summary>

    /// Creates an Image object containing a screen shot the active window

    /// </summary>

    /// <returns></returns>

    public Image CaptureActiveWindow()

    {

      return CaptureWindow( User32.GetForegroundWindow() );

    }

    /// <summary>

    /// Creates an Image object containing a screen shot of the entire desktop

    /// </summary>

    /// <returns></returns>

    public Image CaptureScreen()

    {

      return CaptureWindow( User32.GetDesktopWindow() );

    }   

    /// <summary>

    /// Creates an Image object containing a screen shot of a specific window

    /// </summary>

    /// <param name="handle">The handle to the window. (In windows forms, this is obtained by the Handle property)</param>

    /// <returns></returns>

    private Image CaptureWindow(IntPtr handle)

    {

      // get te hDC of the target window

      IntPtr hdcSrc = User32.GetWindowDC(handle);

      // get the size

      User32.RECT windowRect = new User32.RECT();

      User32.GetWindowRect(handle,ref windowRect);

      int width = windowRect.right - windowRect.left;

      int height = windowRect.bottom - windowRect.top;

      // create a device context we can copy to

      IntPtr hdcDest = GDI32.CreateCompatibleDC(hdcSrc);

      // create a bitmap we can copy it to,

      // using GetDeviceCaps to get the width/height

      IntPtr hBitmap = GDI32.CreateCompatibleBitmap(hdcSrc,width,height);

      // select the bitmap object

      IntPtr hOld = GDI32.SelectObject(hdcDest,hBitmap);

      // bitblt over

      GDI32.BitBlt(hdcDest,0,0,width,height,hdcSrc,0,0,GDI32.SRCCOPY);

      // restore selection

      GDI32.SelectObject(hdcDest,hOld);

      // clean up

      GDI32.DeleteDC(hdcDest);

      User32.ReleaseDC(handle,hdcSrc);

      // get a .NET image object for it

      Image img = Image.FromHbitmap(hBitmap);

      // free up the Bitmap object

      GDI32.DeleteObject(hBitmap);

      return img;

    }

    /// <summary>

    /// Captures a screen shot of the active window, and saves it to a file

    /// </summary>

    /// <param name="filename"></param>

    /// <param name="format"></param>

    public void CaptureActiveWindowToFile(string filename, ImageFormat format)

    {

      Image img = CaptureActiveWindow();

      img.Save(filename,format);

    }

    /// <summary>

    /// Captures a screen shot of the entire desktop, and saves it to a file

    /// </summary>

    /// <param name="filename"></param>

    /// <param name="format"></param>

    public void CaptureScreenToFile(string filename, ImageFormat format)

    {

      Image img = CaptureScreen();

      img.Save(filename,format);

    }   

 

    /// <summary>

    /// Helper class containing Gdi32 API functions

    /// </summary>

    private class GDI32

    {

 

      public const int SRCCOPY = 0x00CC0020; // BitBlt dwRop parameter

      [DllImport("gdi32.dll")]

      public static extern bool BitBlt(IntPtr hObject,int nXDest,int nYDest,

        int nWidth,int nHeight,IntPtr hObjectSource,

        int nXSrc,int nYSrc,int dwRop);

      [DllImport("gdi32.dll")]

      public static extern IntPtr CreateCompatibleBitmap(IntPtr hDC,int nWidth,

        int nHeight);

      [DllImport("gdi32.dll")]

      public static extern IntPtr CreateCompatibleDC(IntPtr hDC);

      [DllImport("gdi32.dll")]

      public static extern bool DeleteDC(IntPtr hDC);

      [DllImport("gdi32.dll")]

      public static extern bool DeleteObject(IntPtr hObject);

      [DllImport("gdi32.dll")]

      public static extern IntPtr SelectObject(IntPtr hDC,IntPtr hObject);

    }

 

    /// <summary>

    /// Helper class containing User32 API functions

    /// </summary>

    private class User32

    {

      [StructLayout(LayoutKind.Sequential)]

      public struct RECT

      {

        public int left;

        public int top;

        public int right;

        public int bottom;

      }

      [DllImport("user32.dll")]

      public static extern IntPtr GetDesktopWindow();

      [DllImport("user32.dll")]

      public static extern IntPtr GetWindowDC(IntPtr hWnd);

      [DllImport("user32.dll")]

      public static extern IntPtr ReleaseDC(IntPtr hWnd,IntPtr hDC);

      [DllImport("user32.dll")]

      public static extern IntPtr GetWindowRect(IntPtr hWnd,ref RECT rect);

      [DllImport("user32.dll")]

      public static extern IntPtr GetForegroundWindow();     

    }

  }

}

'@

#User Add-Type to import the code

add-type $code -ReferencedAssemblies 'System.Windows.Forms','System.Drawing'

#Create the object for the Function

$capture = New-Object ScreenShotDemo.ScreenCapture

 

#Take screenshot of the entire screen

If ($Screen) {

    Write-Verbose "Taking screenshot of entire desktop"

    #Save to a file

    If ($file) {

        If ($file -eq "") {

            $file = "$pwd\image.bmp"

            }

        Write-Verbose "Creating screen file: $file with imagetype of $imagetype"

        $capture.CaptureScreenToFile($file,$imagetype)

        }

    Else {

        $capture.CaptureScreen()

        }

    }

#Take screenshot of the active window   

If ($ActiveWindow) {

    Write-Verbose "Taking screenshot of the active window"

    #Save to a file

    If ($file) {

        If ($file -eq "") {

            $file = "$pwd\image.bmp"

            }

        Write-Verbose "Creating activewindow file: $file with imagetype of $imagetype"

        $capture.CaptureActiveWindowToFile($file,$imagetype)

        }

    Else {

        $capture.CaptureActiveWindow()

        }   

    }   

}

 

Additioanl Powershell scripting sites

http://pshscripts.blogspot.com/

Implementing cookie for page redirect

Problem :

 

I have a requirement for the below scenario where I have to implement this using the browser cookies. This should be done using plain Html or Asp code.

 

E.g..  1 > User access www.example.com

      2 > In the landing page of www.example.com user will have another link for www.xyz.com.

      3 > User access the link in step 2.

      4 > User closes the browser.

      5 > Next time when the user access www.example.com  the user should be redirected to www.xyz.com directly.

 

 

Solution : @http://javascript.internet.com/cookies/cookie-redirect.html:

 

Create a javascript file ‘cookieRedirect.js’ with following code

 

var expDays = 30;

var exp = new Date();

exp.setTime(exp.getTime() + (expDays*24*60*60*1000));

 

function getCookieVal (offset) {

var endstr = document.cookie.indexOf (";", offset);

if (endstr == -1)

endstr = document.cookie.length;

return unescape(document.cookie.substring(offset, endstr));

}

function GetCookie (name) {

var arg = name + "=";

var alen = arg.length;

var clen = document.cookie.length;

var i = 0;

while (i < clen) {

var j = i + alen;

if (document.cookie.substring(i, j) == arg)

return getCookieVal (j);

i = document.cookie.indexOf(" ", i) + 1;

if (i == 0) break;

}

return null;

}

function SetCookie (name, value) {

var argv = SetCookie.arguments;

var argc = SetCookie.arguments.length;

var expires = (argc > 2) ? argv[2] : null;

var path = (argc > 3) ? argv[3] : null;

var domain = (argc > 4) ? argv[4] : null;

var secure = (argc > 5) ? argv[5] : false;

document.cookie = name + "=" + escape (value) +

((expires == null) ? "" : ("; expires=" + expires.toGMTString())) +

((path == null) ? "" : ("; path=" + path)) +

((domain == null) ? "" : ("; domain=" + domain)) +

((secure == true) ? "; secure" : "");

}

function DeleteCookie (name) {

var exp = new Date();

exp.setTime (exp.getTime() - 1);

var cval = GetCookie (name);

document.cookie = name + "=" + cval + "; expires=" + exp.toGMTString();

}

 

var favorite = GetCookie('animal');

 

if (favorite != null) {

switch (favorite) {

case 'cat' :     url = 'cat.html'; // change these!

                 break;

case 'dog' :     url = 'dog.html';

                 break;

case 'gerbil' : url = 'gerbil.html';

                break;

case 'gopher' : url = 'gopher.html';

                break;

}

// window.location.href = url;

alert('You would have been taken to the ' + favorite + ' page (' + url + '), but this is just a demo!');

}

 

 

 

Add following lines to page HEAD

 

<script type="text/javascript" src="cookieRedirect.js"></script>

 

 

Add following lines to page Body

 

<form>

<table><tr><td>

Please choose your Favorite Pet:<br>

<input type=checkbox name="cat" onClick="SetCookie('animal', this.name, exp);">Cat<br>

<input type=checkbox name="dog" onClick="SetCookie('animal', this.name, exp);">Dog<br>

<input type=checkbox name="gerbil" onClick="SetCookie('animal', this.name, exp);">Gerbil<br>

<input type=checkbox name="gopher" onClick="SetCookie('animal', this.name, exp);">Gopher<br>

</td></tr>

</table>

</form>

<br>

(Choose an animal then <a href="cookie-redirect.html">reload</a> the page to see how the redirect works.)

 

 

Outlook 2007 | Asp.Net Interop

invoke the client machine's outlook by creating an ActiveX object using javascript. This way I do not need my application to intertop and install outlook on the server (which would not have met the requirement anyway). Also unlike "mailto" there is no restrcitiion of the length of the email and format of the email could be designed in HTML.

 

 

This javascript would then be registered using Script Manager as I am also using AJAX controls on the site. Here's the code snippet for anyone who has a similar problem to deal with in the future:

 

string script = "var objO = new ActiveXObject('Outlook.Application');var objNS = objO.GetNameSpace('MAPI'); var mItm = objO.CreateItem(0); mItm.Display(); mItm.To = ''; mItm.Subject = '" + EmailReader.LoadEmailSubjectTemplate(Convert.ToInt32(refId)) + "';mItm.HTMLBody = '" + EmailReader.LoadEmailBodyTemplate(Convert.ToInt32(refId)) + "'; mItm.GetInspector.WindowState = 2;";

            if (!ClientScript.IsStartupScriptRegistered(script))

            {

                ScriptManager.RegisterStartupScript(this, this.GetType(), "Nomination", script, true);

            }

 

 

Organic Search | identify source page details

Problem :

 

We had a requirement to personalize a landing page based on what search term the user used when they performed a search on an organic search site (e.g. Google, Yahoo, Bing etc).

 

Here’s the detailed scenario:

1.      User goes to google and enters a search term

2.      Google shows the result set based on the search term

3.      Somewhere in the results will be a link (not sponsored link) to our client’s website

4.      The user clicks the link and comes to our site, at this point we want to know what search term the user used

5.      Based on the search term we would like to target specific content to the user on that page

 

What we want to know is outside of sponsored links, is it possible to identify what search term was used to perform the search. Will it be available in the HTTP header or some other means to get it.

 

 

Solution : [C#]

 

You can use "Referral URL" to extract search term, like with Google, referral URL for "test" (searched test in google.com) will something be like given below (q=test), by parsing the URL you can extract the search term.

In general Your web site visitors could come from different sources, like search engines, blogs, banner ads, affiliates, web directories etc.

To find out which page is generated request to your page, use this code:

 

string MyReferrer = Request.UrlReferrer.ToString();

 

Here is the code for paring the source url:

 

    private String findSearchText(String referrerURL, List paramList) throws UnsupportedEncodingException {

        int queryStringIndex = referrerURL.indexOf("?");

        if (queryStringIndex < 0 || queryStringIndex >= referrerURL.length() - 2) {

            return null;

        }

        referrerURL = referrerURL.substring(queryStringIndex + 1);

        String[] paramSplits = referrerURL.split("&");

        for (int i = 0; i < paramSplits.length; i++) {

            String[] paramValueSplits = paramSplits[i].split("=");

            if (paramValueSplits.length != 2) {

                continue;

            }

            if (paramList.contains(paramValueSplits[0])) {

                return URLDecoder.decode(paramValueSplits[1], UTF_8_ENCODING);

            }

        }

        return null;

    }

 

The List paramlist is the following list:

 

http://.*(google)\\..*/.*=q;as_q;as_epq;as_oq,

http://.*(altavista)\\..*/.*=q,

http://.*(yahoo)\\..*/.*=p,

http://.*(lycos)\\..*/.*=query;wfq,

http://.*(aol)\\..*/.*=query,

http://.*(excite)\\..*/.*=search,

http://.*(go2net)\\..*/.*=general,

http://.*(metacrawler)\\..*/.*=general,

http://.*(msn)\\..*/.*=q;MT,

http://.*(netscape)\\..*/.*=search,

http://.*(looksmart)\\..*/.*=key,

http://.*(webcrawler)\\..*/.*=qkw;search;searchText,

http://.*(overture)\\..*/.*=Keywords,

http://.*(teoma)\\..*/.*=q,

http://.*(infospace)\\..*/.*=qkw,

http://.*(alltheweb)\\..*/.*=q,

http://.*(dogpile)\\..*/.*=q,

http://.*(ask)\\..*/.*=q,ask,

http://.*(alltheweb)\\..*/.*=query,

http://.*(northernlight)\\..*/.*=qr,

http://.*(nlsearch)\\..*/.*=qr,

http://.*(dmoz)\\..*/.*=search

 

 

If at all Banks can work together!!!!!!!!

Online transactions has been so much talked about with so many service providers with showcasing their abilities.

 

I was wondering if I could put something on my site which will enable people pay online without the hassle of me getting subscribed to some online payment gateway and also restricting users for a limited set of banks.

 

Solution : All banks should have option similar to paying via bank to some other bank account, it’s just that the payment will be the other way.

Explanation:

Online user will send a online request from a web portal with their Bank account detail like Account No and IFCS Code.

Online portal will send a request via their bank to the online user bank account for payment.

Online user will accept/reject/update&accept transaction request .

Bank’s does transaction and portal get’s paid.

 

This solution remove security risk outside of the scope of banks, makes it more transparent. Add value to Bank’s.

 

 

 

 

Assign a Strong Name to a Third Party Dll

So here is the scenario – you get a .net dll from somewhere that contains some cool functionality you wish to use in your SharePoint application. The probem is that you can’t sign your own application dll because the referenced third party dll is not signed or strongly named.

When you go to build your VS project you will get the following error – ‘Referenced assembly doesn’t have strong name’

So how can I sign/strongly name the dll I hear you ask? Well here’s how:

1.Open the Visual Studio Command Prompt – probably best to copy the dll in into the VC folder to save you having to cd or type a long path in

2.Create a key pair to sign the assembly – sn.exe –k key.snk

3.Disassemble the dll using ILDASM – ILDASM.exe Yourdll.dll /out=Yourdll.il

This will create a ‘Yourdll.il’ file containing the IL for the assembly. It will also extract the assembly so you will now have a folder with lots of files, you will also see a .res file containing the resources for the dll.

4.Reassemble the dll using ILASM to sign the output with the key created above –ILASM.exe Yourdll.il /dll /out=Yourdll2.dll /key=key.snk

5.Success! 

You should now have a signed version of the dll, you can now add this to your VS project or deploy to the GAC etc   !

 

 

AT Commands and Mobile SMS

Setup HyperTerminal for Mobile


Send SMS via Mobile connected to PC

Useful mobile info :

 

1. *#06# – display the IMEI of the handset

 

2. C# way to send AT Commands to mobile

 

There are few steps you need to perform in order to send AT commands to mobile using C#
1> configure and open the serial port using using System.IO.Ports class
- Serialport.open() and Serialport.close() API are available for doing the same.

2>Write the AT command to opened COM port in step 1.
Serialport.Writeline() API can be used for same. 

Example code is pasted for doing same:

private SerialPort portConfig = new SerialPort();

// configure port 
portConfig.PortName = COM4 ;
.....
.....
//open the port
portConfig.Open();

// send AT command to dial a number
portConfig.WriteLine("ATD" + mobileNumber + ";");

 

 

 

 

AT commands are instructions used to control a modem. AT is the abbreviation of ATtention. Every command line starts with "AT" or "at". That's why modem commands are called AT commands. Many of the commands that are used to control wired dial-up modems, such as ATD (Dial), ATA (Answer), ATH (Hook control) and ATO (Return to online data state), are also supported by GSM/GPRS modems and mobile phones. Besides this common AT command set, GSM/GPRS modems and mobile phones support an AT command set that is specific to the GSM technology, which includes SMS-related commands like AT+CMGS (Send SMS message), AT+CMSS (Send SMS message from storage), AT+CMGL (List SMS messages) and AT+CMGR (Read SMS messages).

Note that the starting "AT" is the prefix that informs the modem about the start of a command line. It is not part of the AT command name. For example, D is the actual AT command name in ATD and +CMGS is the actual AT command name in AT+CMGS. However, some books and web sites use them interchangeably as the name of an AT command.

Here are some of the tasks that can be done using AT commands with a GSM/GPRS modem or mobile phone:

• Get basic information about the mobile phone or GSM/GPRS modem. For example, name of manufacturer (AT+CGMI), model number (AT+CGMM), IMEI number (International Mobile Equipment Identity) (AT+CGSN) and software version (AT+CGMR).
• Get basic information about the subscriber. For example, MSISDN (AT+CNUM) and IMSI number (International Mobile Subscriber Identity) (AT+CIMI).
• Get the current status of the mobile phone or GSM/GPRS modem. For example, mobile phone activity status (AT+CPAS), mobile network registration status (AT+CREG), radio signal strength (AT+CSQ), battery charge level and battery charging status (AT+CBC).
• Establish a data connection or voice connection to a remote modem (ATD, ATA, etc).
• Send and receive fax (ATD, ATA, AT+F*).
• Send (AT+CMGS, AT+CMSS), read (AT+CMGR, AT+CMGL), write (AT+CMGW) or delete (AT+CMGD) SMS messages and obtain notifications of newly received SMS messages (AT+CNMI).
• Read (AT+CPBR), write (AT+CPBW) or search (AT+CPBF) phonebook entries.
• Perform security-related tasks, such as opening or closing facility locks (AT+CLCK), checking whether a facility is locked (AT+CLCK) and changing passwords (AT+CPWD).
  (Facility lock examples: SIM lock [a password must be given to the SIM card every time the mobile phone is switched on] and PH-SIM lock [a certain SIM card is associated with the mobile phone. To use other SIM cards with the mobile phone, a password must be entered.])
• Control the presentation of result codes / error messages of AT commands. For example, you can control whether to enable certain error messages (AT+CMEE) and whether error messages should be displayed in numeric format or verbose format (AT+CMEE=1 or AT+CMEE=2).
• Get or change the configurations of the mobile phone or GSM/GPRS modem. For example, change the GSM network (AT+COPS), bearer service type (AT+CBST), radio link protocol parameters (AT+CRLP), SMS center address (AT+CSCA) and storage of SMS messages (AT+CPMS).
• Save and restore configurations of the mobile phone or GSM/GPRS modem. For example, save (AT+CSAS) and restore (AT+CRES) settings related to SMS messaging such as the SMS center address.

Note that mobile phone manufacturers usually do not implement all AT commands, command parameters and parameter values in their mobile phones. Also, the behavior of the implemented AT commands may be different from that defined in the standard. In general, GSM/GPRS modems designed for wireless applications have better support of AT commands than ordinary mobile phones.

In addition, some AT commands require the support of mobile network operators. For example, SMS over GPRS can be enabled on some GPRS mobile phones and GPRS modems with the +CGSMS command (command name in text: Select Service for MO SMS Messages). But if the mobile network operator does not support the transmission of SMS over GPRS, you cannot use this feature.

 

14.1. Basic Commands and Extended Commands

There are two types of AT commands: basic commands and extended commands.

Basic commands are AT commands that do not start with "+". For example, D (Dial), A (Answer), H (Hook control) and O (Return to online data state) are basic commands.

Extended commands are AT commands that start with "+". All GSM AT commands are extended commands. For example, +CMGS (Send SMS message), +CMSS (Send SMS message from storage), +CMGL (List SMS messages) and +CMGR (Read SMS messages) are extended commands. The general syntax of extended AT commands is straightforward. The syntax rules are provided below. The syntax of basic AT commands is slightly different. We will not cover the syntax of basic AT commands in this SMS tutorial since all SMS messaging commands are extended AT commands.

 

Syntax rule 1. All command lines must start with "AT" and end with a carriage return character. (We will use <CR> to represent a carriage return character in this SMS tutorial.) In a terminal program like HyperTerminal of Microsoft Windows, you can press the Enter key on the keyboard to output a carriage return character.

Example: To list all unread inbound SMS messages stored in the message storage area, type "AT", then the extended AT command "+CMGL", and finally a carriage return character, like this:

 

AT+CMGL<CR>

 

Syntax rule 2. A command line can contain more than one AT command. Only the first AT command should be prefixed with "AT". AT commands in the same command-line string should be separated with semicolons.

Example: To list all unread inbound SMS messages stored in the message storage area and obtain the manufacturer name of the mobile device, type "AT", then the extended AT command "+CMGL", followed by a semicolon and the next extended AT command "+CGMI":

 

AT+CMGL;+CGMI<CR>

 

An error will occur if both AT commands are prefixed with "AT", like this:

 

AT+CMGL;AT+CGMI<CR>

 

Syntax rule 3. A string is enclosed between double quotes.

Example: To read all SMS messages from message storage in SMS text mode (at this time you do not need to know what SMS text mode is. More information will be provided later in this SMS tutorial), you need to assign the string "ALL" to the extended AT command +CMGL, like this:

 

AT+CMGL="ALL"<CR>

 

Syntax rule 4. Information responses and result codes (including both final result codes and unsolicited result codes) always start and end with a carriage return character and a linefeed character.

Example: After sending the command line "AT+CGMI<CR>" to the mobile device, the mobile device should return a response similar to this:

 

<CR><LF>Nokia<CR><LF>
<CR><LF>OK<CR><LF>

 

The first line is the information response of the AT command +CGMI and the second line is the final result code. <CR> and <LF> represent a carriage return character and a linefeed character respectively. The final result code "OK" marks the end of the response. It indicates no more data will be sent from the mobile device to the computer / PC.

When a terminal program such as HyperTerminal of Microsoft Windows sees a carriage return character, it moves the cursor to the beginning of the current line. When it sees a linefeed character, it moves the cursor to the same position on the next line. Hence, the command line "AT+CGMI<CR>" that you entered and the corresponding response will be displayed like this in a terminal program such as HyperTerminal of Microsoft Windows:

 

AT+CGMI
Nokia

OK

 

15.1. Information Response and Final Result Code

Don't forget the meanings of information response and final result code stated above, since you will see these two terms frequently as you go through this SMS tutorial.

 

AT+CGMI  <-- Command line entered
Nokia  <-- Information response

OK  <-- Final result code

 

15.2. Case Sensitivity of AT Commands

In the SMS specification, all AT commands are in uppercase letters. However, many GSM/GPRS modems and mobile phones allow you to type AT commands in either uppercase or lowercase letters. For example, on Nokia 6021, AT commands are case-insensitive and the following two command lines are equivalent:

 

AT+CMGL<CR>

 

at+cmgl<CR>

Result codes are messages sent from the GSM/GPRS modem or mobile phone to provide you information about the execution of an AT command and the occurrence of an event. Two types of result codes are useful to you when dealing with AT commands for SMS messaging:

• Final result codes
• Unsolicited result codes

 

16.1. Final Result Codes of AT Commands

A final result code marks the end of an AT command response. It is an indication that the GSM/GPRS modem or mobile phone has finished the execution of a command line. Two frequently used final result codes are OK and ERROR. Only one final result code will be returned for each command line. Thus, you will not see both OK and ERROR in the response of a command line.

 

16.1.1. The OK Final Result Code

The OK final result code indicates that a command line has been executed successfully by the GSM/GPRS modem or mobile phone. It always starts and ends with a carriage return character and a linefeed character.

Here is an example for illustration. Let's say you send the command line "AT+CMGL;+CGMI<CR>" to your GSM/GPRS modem. The AT command "+CMGL" is used to list SMS messages stored in the message storage area and the AT command "+CGMI" is used to get the manufacturer name of the GSM/GPRS modem. If everything works properly without any errors, the command line, together with the response returned, should be something similar to this:

 

AT+CMGL;+CGMI<CR>
<CR><LF>+CMGL: 1,"REC UNREAD","+85291234567",,"06/11/11,00:30:29+32"<CR><LF>
Welcome to our SMS tutorial.<CR><LF>
<CR><LF>Nokia<CR><LF>
<CR><LF>OK<CR><LF>

 

As mentioned earlier, when a terminal program such as HyperTerminal of Microsoft Windows sees a carriage return character, it moves the cursor to the beginning of the current line. When it sees a linefeed character, it moves the cursor to the same position on the next line. Hence, the command line you entered, together with the response returned, will be displayed like this in a terminal program such as HyperTerminal of Microsoft Windows:

 

AT+CMGL;+CGMI
+CMGL: 1,"REC UNREAD","+85291234567",,"06/11/11,00:30:29+32"
Welcome to our SMS tutorial.

Nokia

OK

 

16.1.2. The ERROR Final Result Code

The ERROR final result code indicates that an error occurs when the GSM/GPRS modem or mobile phone tries to execute a command line. After the occurrence of an error, the GSM/GPRS modem or mobile phone will not process the remaining AT commands in the command-line string.

Below are some common causes of error:

• The syntax of the command line is incorrect.
• The value specified to a certain parameter is invalid.
• The name of the AT command is spelt incorrectly.
• The GSM/GPRS modem or mobile phone does not support one or more of the AT commands, command parameters or parameter values in the command-line string.

Like the OK final result code, the ERROR final result code always starts and ends with a carriage return character and a linefeed character.

Here is an example for illustration. Suppose you want to instruct your GSM/GPRS modem to list SMS messages from the message storage area and get the manufacturer name of the GSM/GPRS modem. You intend to type the command line "AT+CMGL;+CGMI<CR>" but make a careless mistake by typing "+CMFL" instead of "+CMGL". The GSM/GPRS modem will return the ERROR final result code, as shown below:

 

AT+CMFL;+CGMI<CR>
<CR><LF>ERROR<CR><LF>

 

As an error occurs when the GSM/GPRS modem processes "+CMFL", the GSM/GPRS modem stops the execution of the command line and so the second AT command "+CGMI" is not processed.

If you type the second AT command "+CGMI" incorrectly instead of the first AT command "+CMGL", the GSM/GPRS modem will output the result of the execution of the AT command "+CMGL" before outputting the ERROR final result code, like this:

 

AT+CMGL;+CGMU<CR>
<CR><LF>+CMGL: 1,"REC UNREAD","+85291234567",,"06/11/11,00:30:29+32"<CR><LF>
Welcome to our SMS tutorial.<CR><LF>
<CR><LF>ERROR<CR><LF>

 

As mentioned earlier, when a terminal program such as HyperTerminal of Microsoft Windows sees a carriage return character, it moves the cursor to the beginning of the current line. When it sees a linefeed character, it moves the cursor to the same position on the next line. Hence, the command line you entered, together with the response returned, will be displayed like this in a terminal program such as HyperTerminal of Microsoft Windows:

 

AT+CMGL;+CGMU
+CMGL: 1,"REC UNREAD","+85291234567",,"06/11/11,00:30:29+32"
Welcome to our SMS tutorial.

ERROR

The final result codes OK and ERROR are available to all AT commands. Unlike OK and ERROR, the +CMS ERROR final result code is only available to SMS AT commands. It notifies you about the occurrence of a message service failure.

 

16.2.1. The +CMS ERROR Final Result Code -- Notifies the Occurrences and Causes of Message Service Failures

The +CMS ERROR final result code is returned when a message service failure occurs. An error code is provided for programmers to check what causes the message service failure. The +CMS ERROR final result code is specific to SMS AT commands, i.e. the +CMS ERROR final result code will only be outputted by AT commands that are used to perform tasks related to SMS messaging. Below are the SMS AT commands that may output the final result code +CMS ERROR:

• +CMGC (command name in text: Send Command)
• +CMGD (command name in text: Delete Message)
• +CMGL (command name in text: List Messages)
• +CMGR (command name in text: Read Message)
• +CMGS (command name in text: Sending Message)
• +CMGW (command name in text: Write Message to Memory)
• +CMSS (command name in text: Send Message from Storage)
• +CNMA (command name in text: New Message Acknowledgement to ME/TA)
• +CNMI (command name in text: New Message Indications to TE)
• +CPMS (command name in text: Preferred Message Storage)
• +CRES (command name in text: Restore Settings)
• +CSAS (command name in text: Save Settings)
• +CSMS (command name in text: Select Message Service)

The syntax of the +CMS ERROR final result code is:

 

<CR><LF>+CMS ERROR: error_code<CR><LF>

 

Just as the final result codes OK and ERROR, the +CMS ERROR final result code always starts and ends with a carriage return character and a linefeed character. error_code is an integer that is associated to a certain error. A list of some error codes and their meanings can be found in "Table of +CMS Error Codes and Their Meanings".

As mentioned earlier, after the execution of a command line, only one final result code is returned. Hence, when an error occurs, you will not find both +CMS ERROR and ERROR in the command response. For errors related to SMS messaging, the +CMS ERROR final result code is returned. For other errors such as invalid command syntax and unsupported AT command, the ERROR final result code is returned as usual.

Below shows some common causes of +CMS errors:

• A SIM card is not present in the GSM/GPRS modem or mobile phone.
• The SIM card requires a password (e.g. PIN, PIN2, PUK and PUK2) but you have not entered it.
• An invalid memory index is assigned to an AT command.
• The memory of the GSM/GPRS modem, mobile phone or SIM card for storing SMS messages is full.
• The SMSC address is unknown or incorrect.

Following is an example that demonstrates the usage of the +CMS ERROR result code. Let's say there is only one SMS text message stored on our Nokia 6021 and it is stored in the memory location at index 1. If we enter the command line "AT+CMGR=11" (it means "to read the SMS message at memory index 11"), Nokia 6021 will return a +CMS error:

 

AT+CMGR=11<CR>
<CR><LF>+CMS ERROR: 321<CR><LF>

 

As mentioned earlier, when a terminal program such as HyperTerminal of Microsoft Windows sees a carriage return character, it moves the cursor to the beginning of the current line. When it sees a linefeed character, it moves the cursor to the same position on the next line. Hence, the command line you entered, together with the response returned, will be displayed like this in a terminal program such as HyperTerminal of Microsoft Windows:

 

AT+CMGR=11
+CMS ERROR: 321

 

To find out the meaning of the +CMS error code 321, go to "Table of +CMS Error Codes and Their Meanings". From there, we know that the read message operation failed because an invalid memory index was assigned to the AT command +CMGR.

Note that after the occurrence of a +CMS error, the GSM/GPRS modem or mobile phone will not process the remaining AT commands in the command line. Thus, if the command line sent to Nokia 6021 is "AT+CMGR=11;+CGMI" (+CGMI is the AT command for retrieving the manufacturer name of the GSM/GPRS modem or mobile phone), you will get the following result in Windows' HyperTerminal:

 

AT+CMGR=11;+CGMI
+CMS ERROR: 321

 

But if the positions of the two AT commands in the command line are exchanged, Nokia 6021 will output the result of the execution of the AT command +CGMI before outputting the +CMS ERROR result code. Below is the result displayed in Windows' HyperTerminal:

 

AT+CGMI;+CMGR=11
Nokia

+CMS ERROR: 321

 

16.2.1.1. Table of +CMS Error Codes and Their Meanings

The following table lists some of the +CMS error codes and their meanings.

 

+CMS error code	Meaning
300	Mobile equipment (ME) failure. Mobile equipment refers to the mobile device that communicates with the wireless network. Usually it is a mobile phone or GSM/GPRS modem. The SIM card is defined as a separate entity and is not part of mobile equipment.
301	SMS service of mobile equipment (ME) is reserved. See +CMS error code 300 for the meaning of mobile equipment.
302	The operation to be done by the AT command is not allowed.
303	The operation to be done by the AT command is not supported.
304	One or more parameter values assigned to the AT command are invalid. (For PDU mode)
305	One or more parameter values assigned to the AT command are invalid. (For Text mode)
310	There is no SIM card.
311	The SIM card requires a PIN to operate. The AT command +CPIN (command name in text: Enter PIN) can be used to send the PIN to the SIM card.
312	The SIM card requires a PH-SIM PIN to operate. The AT command +CPIN (command name in text: Enter PIN) can be used to send the PH-SIM PIN to the SIM card.
313	SIM card failure.
314	The SIM card is busy.
315	The SIM card is wrong.
316	The SIM card requires a PUK to operate. The AT command +CPIN (command name in text: Enter PIN) can be used to send the PUK to the SIM card.
320	Memory/message storage failure.
321	The memory/message storage index assigned to the AT command is invalid.
322	The memory/message storage is out of space.
330	The SMS center (SMSC) address is unknown.
331	No network service is available.
332	Network timeout occurred.
340	There is no need to send message acknowledgement by the AT command +CNMA (command name in text: New Message Acknowledgement to ME/TA).
500	An unknown error occurred.

Unsolicited result codes are messages sent from the GSM/GPRS modem or mobile phone to provide you information about the occurrence of an event. For example, you can use the +CNMI AT command (command name in text: New Message Indications to TE) to request the GSM/GPRS modem or mobile phone to send the unsolicited result code "+CMTI" to your computer / PC every time a new SMS message is received from the SMS center.

Here are the unsolicited result codes that are related to SMS messaging:

 

+CDS

A GSM/GPRS modem or mobile phone uses +CDS to forward a newly received SMS status report to the computer / PC.

 

+CDSI

A GSM/GPRS modem or mobile phone uses +CDSI to notify the computer / PC that a new SMS status report has been received and the memory location where it is stored.

 

+CMT

A GSM/GPRS modem or mobile phone uses +CMT to forward a newly received SMS message to the computer / PC.

 

+CMTI

A GSM/GPRS modem or mobile phone uses +CMTI to notify the computer / PC that a new SMS message has been received and the memory location where it is stored.

There are four types of AT command operations:

• Test operation. A test operation is used to check whether a certain AT command is supported by the GSM/GPRS modem or mobile phone.
• Set operation. A set operation is used to change the settings used by the GSM/GPRS modem or mobile phone for certain tasks.
• Read operation. A read operation is used to retrieve the current settings used by the GSM/GPRS modem or mobile phone for certain tasks.
• Execution operation. An execution operation is used to perform an action or retrieve information/status about the GSM/GPRS modem or mobile phone.

The command syntax for performing an operation will be described in detail in the following sections.

 

17.1. Test Command -- Checks Whether a Certain AT Command is Supported

A test operation is used to check whether a certain AT command is supported by the GSM/GPRS modem or mobile phone. All extended AT commands support the test operation. The syntax is:

 

command=?

 

where command is an AT command. When an AT command is used in the above syntax to perform a test operation, it is called a test command.

Here is an example. The AT command +CGMI (command name in text: Request Manufacturer Identification) is used to get the manufacturer name of the GSM/GPRS modem or mobile phone. To test whether +CGMI is supported, you can make use of the test command "+CGMI=?". The complete command line that should be entered is:

 

AT+CGMI=?

 

If the GSM/GPRS modem or mobile phone supports the AT command +CGMI, the result code "OK" will be returned, like this:

 

AT+CGMI=?
OK

 

If the GSM/GPRS modem or mobile phone does not support the AT command +CGMI, the result code "ERROR" will be returned, like this:

 

AT+CGMI=?
ERROR

 

In the above example, the AT command +CGMI does not have any parameters. If the AT command to be tested has parameter(s), the parameter value(s) supported by the GSM/GPRS modem or mobile phone may be printed additionally. Below is an example that illustrates the format of the response. +COMMAND1 is a fictitious AT command that has four parameters.

 

AT+COMMAND1=?
+COMMAND1: (0,1),(0-10),(0,1,5-10),("GSM","UCS2")

OK

 

The supported values of each of the four parameters are enclosed in parentheses. Commas are used to delimit the parentheses and the values inside parentheses. A hyphen is used to indicate a range of values. The values inside parentheses can be of the string type.

In the above example, the response of the test command "+COMMAND1=?" provides us the following information:

• (0,1). The first parameter accepts either 0 or 1.
• (0-10). The second parameter accepts any integer between 0 and 10.
• (0,1,5-10). The third parameter accepts 0, 1 or any integer between 5 and 10.
• ("GSM","UCS2"). The fourth parameter accepts either the string "GSM" or "UCS2".

To a few AT commands, the test operation does not return the parameter values supported. Instead, it returns the values that are allowed to appear in the information response of the AT command. An example is the +CBC AT command (command name in text: Battery Charge). The +CBC command is used to retrieve the connection status and charge level of the battery of the mobile device. Two values are returned in the information response of the +CBC AT command. The format is:

 

+CBC: connection_status,charge_level

 

For example, if the battery is placed in the mobile device with no charger connected and the charge level is 80%, the result of the execution of the +CBC AT command will be:

 

AT+CBC
+CBC: 0,80

OK

 

If you run the test command "+CBC=?", all the supported values that are allowed to appear in the connection status field and charge level field will be provided. With my Nokia 6021, the result is:

 

AT+CBC=?
+CBC: (0,1),(0-100)

OK

 

"(0,1)" means the connection status field in the information response of the +CBC AT command can contain either 0 or 1, while "(0-100)" means the charge level field can contain any integer between 0 and 100.

A set operation changes the settings used by the GSM/GPRS modem or mobile phone for certain tasks. The syntax is:

 

command=value1,value2,...valueN

 

where command is an AT command and value1 to valueN are the values you want to set. When an AT command is used in the above syntax to perform a set operation, it is called a set command.

Here is an example. The AT command +CSCA (command name in text: Service Centre Address) is used to set the SMSC (SMS center) address for sending SMS messages. It takes two parameters that specify the SMSC address and type of address. To set the SMSC address to +85291234567, enter the following command line in a terminal program such as MS Windows' HyperTerminal:

 

AT+CSCA="+85291234567",145

 

If the set command runs successfully, the result code "OK" will be returned:

 

AT+CSCA="+85291234567",145
OK

 

Some AT commands have optional parameters. You can choose not to assign values to them. For example, the second parameter of the +CSCA AT command is optional. If no value is assigned to the second parameter, the GSM/GPRS modem or mobile phone will use the default parameter value, which is 145 if the SMSC address starts with "+" (the plus character). Hence, this command line:

 

AT+CSCA="+85291234567"

 

is equivalent to:

 

AT+CSCA="+85291234567",145

 

Typically the values you specified with set commands are placed in volatile memory. If the GSM/GPRS modem or mobile phone is switched off or rebooted, the values you specified with set commands will be gone. When the GSM/GPRS modem or mobile phone is powered on again, all settings are back to the defaults.

For some commonly used settings, there are AT commands for saving/restoring the settings to/from non-volatile memory. For example, the AT commands +CSAS (command name in text: Save Settings) and +CRES (command name in text: Restore Settings) can be used to save and restore settings related to SMS messaging such as the SMS center address.

A read operation retrieves the current settings used by the GSM/GPRS modem or mobile phone for certain tasks. The syntax is:

 

command?

 

where command is an AT command. When an AT command is used in the above syntax to perform a read operation, it is called a read command. The read operation is supported by all AT commands that are capable of the set operation.

Here is an example that illustrates how to use a read command. The AT command +CSCA (command name in text: Service Centre Address) is used to set the SMSC (SMS center) address for sending SMS messages. It takes two parameters that specify the SMSC address and type of address. Suppose you set the SMSC address to +85291234567 in Microsoft HyperTerminal, like this:

 

AT+CSCA="+85291234567",145
OK

 

After that, if you enter the read command "+CSCA?", the GSM/GPRS modem or mobile phone will return the SMSC address and type of address that you set in the previous step:

 

AT+CSCA?
+CSCA: "+85291234567",145

OK

An execution operation is used to perform an action (for example, send or read an SMS message) or retrieve information/status about the GSM/GPRS modem or mobile phone (for example, retrieve the current battery charge level, battery charging status or radio signal strength of the mobile network). The syntax is:

 

command=value1,value2,...valueN

 

where command is an AT command and value1 to valueN are the values to assign to the AT command. If the AT command does not have any parameters, the part "=value1,value2,...valueN" should be omitted. When an AT command is used in the above syntax to perform an execution operation, it is called an execution command.

Here is an example illustrating the use of an execution command. The AT command +CMSS (command name in text: Send Message from Storage) can be used to perform an execution operation to send an SMS message stored in message storage. It has three parameters. They specify the index of the memory location that stores the SMS message, the destination phone number and the type of the phone number respectively. To send the SMS message at index 1 to the phone number +85291234567, the following command line can be used:

 

AT+CMSS=1,"+85291234567",145

 

Some AT commands have optional parameters. You can choose not to assign values to them. For example, the third parameter of the +CMSS AT command is optional. If no value is assigned to the third parameter, the GSM/GPRS modem or mobile phone will use the default parameter value, which is 145 if the destination phone number starts with "+" (the plus character). Hence, this command line:

 

AT+CMSS=1,"+85291234567"

 

is equivalent to:

 

AT+CMSS=1,"+85291234567",145

 

Unlike set commands, execution commands do not store the parameter values assigned to them. So, no read command is available for retrieving the last parameter values assigned to an execution command. For example, if you send the command line "AT+CMSS?" to your GSM/GPRS modem or mobile phone, the ERROR result code will be returned:

 

AT+CMSS?
ERROR

Suppose you have connected your GSM/GPRS modem or mobile phone to your PC / computer and started a terminal program (such as HyperTerminal on Microsoft Windows). Now you are ready to enter your first command. The first thing that is usually done is to test the communication between the PC and GSM/GPRS modem/mobile phone to confirm that everything is working properly so far. Simply enter "AT" in the terminal program to perform the test. When the GSM/GPRS modem or mobile phone receives "AT", it will send back the final result code "OK" to indicate that it has received your command successfully, like this:

 

AT
OK

After testing the communication between the PC and GSM/GPRS modem/mobile phone, the next thing that you may want to do is to check if the GSM/GPRS modem or mobile phone supports the use of AT commands to send, receive and read SMS messages. Most GSM/GPRS modems support all three functions. However, only some mobile phones support all of them.

 

Sending SMS Messages

To find out whether a GSM/GPRS modem or mobile phone supports the sending of SMS messages through AT commands, you have to:

1. Use the AT command +CSMS (command name in text: Select Message Service) to check whether mobile-originated SMS messages are supported.
2. Perform test operations to check whether +CMGS (command name in text: Send Message) and/or +CMSS (command name in text: Send Message from Storage) are supported.
   (You may want to check the AT commands +CMGW [command name in text: Write Message to Memory] and +CMGD [command name in text: Delete Message] in addition as they are sometimes used together with +CMSS.)

 

Receiving SMS Messages and Reading SMS Messages from Message Storage

To find out whether a GSM/GPRS modem or mobile phone supports the receiving and reading of SMS messages through AT commands, you have to:

1. Use the AT command +CSMS (command name in text: Select Message Service) to check whether mobile-terminated SMS messages are supported.
2. Perform test operations to check whether +CNMI (command name in text: New Message Indications to TE), +CMGL (command name in text: List Messages) and/or +CMGR (command name in text: Read Message) are supported.

If the GSM/GPRS modem or mobile phone supports the +CNMI AT command, it can send a notification or directly forward the message to the PC whenever a new SMS message arrives.

If the GSM/GPRS modem or mobile phone does not support +CNMI but supports +CMGL and/or +CMGR, the PC has to poll the GSM/GPRS modem or mobile phone repeatedly in order to know if any new SMS messages have arrived.

One use of the AT command +CSMS (command name in text: Select Message Service) is to check the message types supported by the GSM/GPRS modem or mobile phone. There are three message types: mobile-originated SMS messages, mobile-terminated SMS messages and cell broadcast messages.

Mobile-originated SMS messages refer to SMS messages that are sent from a mobile device to an SMSC, i.e. outbound SMS messages.

Mobile-terminated SMS messages refer to SMS messages that are sent from an SMSC to a mobile device, i.e. inbound SMS messages.

Cell broadcast messages are text messages pushed to subscribers located in a certain mobile network area by the network operator. These text messages may contain news, weather information, etc.

Here is an example that demonstrates how to use the +CSMS AT command to check if mobile-originated and mobile-terminated SMS messages are supported. First, send the read command "+CSMS?" to the GSM/GPRS modem or mobile phone. The response returned from our Nokia 6021 to HyperTerminal is shown below:

 

AT+CSMS?
+CSMS: 0,1,1,1

OK

 

As you can see, the information response contains four values. The second, third and fourth values indicate whether Nokia 6021 supports mobile-terminated SMS messages, mobile-originated SMS messages and cell broadcast messages respectively. If the value is 1, it means the message type is supported. If the value is 0, it means the message type is not supported.

For Nokia 6021:

• The third value in the information response is 1, which indicates Nokia 6021 supports mobile-originated SMS messages. So, Nokia 6021 is capable of sending SMS messages to an SMSC.
• The second value in the information response is 1, which indicates Nokia 6021 supports mobile-terminated SMS messages. So, Nokia 6021 is capable of receiving SMS messages from an SMSC.

If the final result code "ERROR" is returned (as shown below), it is likely that the +CSMS AT command is not supported by the mobile device.

 

AT+CSMS?
ERROR

 

To confirm, send the test command "+CSMS=?" to the GSM/GPRS modem or mobile phone. If the final result code "ERROR" is returned (as shown below), it means the mobile device does not support the +CSMS AT command.

 

AT+CSMS=?
ERROR

 

Note that +CSMS is a mandatory command in the AT command set for SMS messaging. If it is not supported, normally the whole AT command set for SMS messaging is not supported.

The next thing to do is to check if the AT commands required for sending, receiving and reading SMS messages are supported by the mobile phone or GSM/GPRS modem. As pointed out earlier in this SMS tutorial, you can check if a certain AT command is supported by performing a test operation. Simply execute an AT command with "=?" attached at its end. For example, "AT+CMGS=?".

Before we begin the check, let's go through an overview of the AT commands that are required for sending, receiving and reading SMS messages. You will learn which AT commands should be checked and get a general idea about when these AT commands should be used.

 

19.2.1. Overview of the AT Commands Required

 

For Sending SMS Messages

To send SMS messages via AT commands, the GSM/GPRS modem or mobile phone has to support either +CMGS (command name in text: Send Message) or +CMSS (command name in text: Send Message from Storage). You may also find +CMGW (command name in text: Write Message to Memory) and +CMGD (command name in text: Delete Message) useful, since they are sometimes used together with +CMSS. +CMSS is used to send an SMS message located in the message storage area. If an SMS message does not exist in the message storage area, you must first use the AT command +CMGW to write the SMS message to the message storage area before you can use the AT command +CMSS to send the SMS message to the SMSC. After message submission, you may use the AT command +CMGD to delete the SMS message to free some space from the message storage area.

 

For Receiving and Reading SMS Messages

To receive and read SMS messages via AT commands, the GSM/GPRS modem or mobile phone has to support the AT command +CNMI (command name in text: New Message Indications to TE. TE stands for Terminal Equipment, which is the equipment that controls the GSM/GPRS modem or mobile phone. For example, a PC / computer), +CMGL (command name in text: List Messages), or +CMGR (command name in text: Read Messages).

The AT command +CNMI is used to specify how newly arrived SMS messages should be handled. You can tell the GSM/GPRS modem or mobile phone either to forward newly arrived SMS messages directly to the PC, or to save them in message storage and then notify the PC about their locations in message storage.

The AT command +CMGL is used to read all SMS messages that have a certain status (e.g. "received unread", "received read", etc) from the message storage area, while the AT command +CMGR is used to read the SMS message saved at a certain location of the message storage area.

 

19.2.2. Beginning the Check

Now that you've learned the AT commands required for outbound and inbound SMS messaging are +CMGS, +CMSS, +CNMI, +CMGL and +CMGR. You can begin the check by performing a test operation with each of the AT commands. For example, you can execute the command line "AT+CMGS=?" to check whether +CMGS is supported, like this:

 

AT+CMGS=?
OK

 

The final result code "OK" indicates the AT command +CMGS is supported. If the GSM/GPRS modem or mobile phone returns the final result code "ERROR", it means the command is not supported.

A quicker way is to copy and paste the following command line to the terminal program and execute it:

 

AT+CMGS=?;+CMSS=?;+CNMI=?;+CMGL=?;+CMGR=?

 

As an example, here shows the response returned from my Nokia 6021 to HyperTerminal after the execution of above command line:

 

AT+CMGS=?;+CMSS=?;+CNMI=?;+CMGL=?;+CMGR=?
+CNMI: (0-2),(0-3),(0,2,3),(0-2),(0,1)

+CMGL: (0-4)

OK

 

The return of the final result code "OK" indicates all AT commands under test are supported. If the final result code "ERROR" is returned, it means one or more AT commands are not supported.

The SMS specification has defined two modes in which a GSM/GPRS modem or mobile phone can operate. They are called SMS text mode and SMS PDU mode. (PDU stands for Protocol Data Unit.) The mode that a GSM/GPRS modem or mobile phone is operating in determines the syntax of some SMS AT commands and the format of the responses returned after execution. Below are the SMS AT commands affected:

• +CMGS (Send Message)
• +CMSS (Send Message from Storage)
• +CMGR (Read Message)
• +CMGL (List Messages)
• +CMGW (Write Message to Memory)
• +CNMA (New Message Acknowledgement to ME/TA)
• +CMGC (Send Command)

The syntax of the unsolicited result codes below also depends on the mode in which the GSM/GPRS modem or mobile phone is operating:

• +CMT (Used to forward received SMS messages to the computer / PC.)
• +CBM (Used to forward received cell broadcast messages to the computer / PC.)
• +CDS (Used to forward received status reports to the computer / PC.)

These two AT commands are useful to you only if SMS text mode is used:

• +CSMP (Set Text Mode Parameters)
• +CSDH (Show Text Mode Parameters)

 

Refer : http://www.developershome.com/sms/