Future Technologies Solution

Android hacking

2017-07-28T12:27:00.001+05:30

https://youtu.be/noEdPBt0pQc

How to Access Someone Else's WhatsApp/Hike/Line/Wechat Account

2015-10-11T00:43:00.001+05:30

How to Access Someone Else's WhatsApp/Hike/Line/Wechat Account

*****************************************************************************************************************************************************************************************************************

Requirement: Rooted android Device,BusyBox,Terminal Emulator

MAC Spoofing

Uninstall WhatsApp from your phone or device. You'll install it again at the end of the method, but you'll need to configure it differently, and the easiest way to make sure you'll be able to do that correctly is to completely uninstall it now.

Obtain your target's phone. You'll need it for two different steps throughout the process, but this shouldn't take too long - you should be able to return it before your target starts to miss it.

Find your target's phone's Media Access Control (MAC) address. A MAC address is a unique identifier assigned to your phone or other device that essentially serves as its online identity. Find and write down your target's MAC address. It takes the form of six pairs of letters or numbers, separated by colons (01:23:45:67:89:ab).

On an Android, find this in Settings → About phone → Status → Wi-Fi MAC address.
On an iPhone, go to Settings → General → About → Wi-Fi Address.
On a Windows phone, look in Settings → About → More info → MAC address.
On a BlackBerry, go to Options → Device → Device and Status info → WLAN MAC.

Find your MAC address using the instructions above. Make sure to save it somewhere secure, as you'll want to change your device back to that address once you're done.

Change ("spoof") your phone's MAC address to that of your target. This will allow your phone to pass as your target's, letting you convince WhatsApp that you are your target when you log in.

On an iPhone or other device, install a MAC spoofing app like MacDaddy X or WifiSpoof. Use that to change your MAC address.
On Android, install BusyBox and the Terminal Emulator (apps available for free on Google Play). In the terminal, type "ip link show" to see a list of interfaces. Identify the one that has your MAC address -- for this example, we'll use the wlan0 interface. In the terminal emulator, enter "ip link set wlan0 address XX:XX:XX:XX:XX:XX" and "ip link set wlan0 broadcast XX:XX:XX:XX:XX:XX", where wlan0 is the interface you identified and XX:XX:XX:XX:XX:XX is your target's MAC address. To check that you've successfully changed your MAC address, enter "ip link show wlan0."

Install and configure WhatsApp on your phone. Enter your target's phone number to set up WhatsApp rather than your own. This will allow you to receive their messages and send messages from their account.

Get the confirmation code from your target's phone This code will be sent to their phone number as part of the WhatsApp configuration process. Access their phone one last time to get that verification code.Enter it into WhatsApp on your phone when prompted, and you're all ready to go. Accessing the phone is not important because it will automatically give access to their WhatsApp accounts, when we enter the yarget's phone number to set up WhatsApp. But in certain cases its important to access the phone.

Note:- If you don't want your target to find out about your spoofing, make sure to delete the confirmation code from their phone before they can see it.

When you no longer need to access your target's WhatsApp account, change your MAC address back to what it was. Repeat the instructions to change it, but this time change it to your original address rather than your target's. This will restore your phone to how it was originally, which will ensure that there are no future problems with Internet usage or connectivity.

Note:-You can also use this trick for transferring mcent money to your account.

HTML5 Mobile App Development Using Intel XDK

2015-10-10T20:43:00.001+05:30

Cross-platform mobile application development is a technique of writing single codebase for apps that will be in the end installed and used in different mobile operating systems. Applications built using this technique are called as cross-platform mobile apps. Cross-platform mobile apps that are written in HTML, CSS and JavaScript are called as hybrid apps.

In this article we will learn how to create hybrid apps using Intel XDK and design hybrid apps using Ionic design components. In this chapter we will specifically cover what is Intel XDK, why you should use Intel XDK, how does Intel XDK work and its limitations.

What Do You Need to Know?
Before you start learning to create hybrid apps using Intel XDK and Ionic you need to know basics of how to create websites that is you should know basics of HTML, CSS, JavaScript and any backend technology. Mostly web developers are the ones who prefer to create hybrid apps, as they don’t have to learn new programming languages and frameworks for creating mobile apps.

Native, Hybrid and Web apps
You will often hear the terms native app, hybrid app and web app. Often developers get confused between these terms therefore it’s important to clearly understand the meaning of each of these terms.

Native Apps: Native apps live on the device and are opened through icons on the device home screen. They are developed to work specifically on one operating system. They are installed through platform specific stores. They can take advantage of all device features and can work offline.
Web Apps: Web apps are websites that are designed to look and behave like native apps – for example: they can hide browser’s UI components, scale according to the screen width etc. Users can also add them to the home screen. HTML5 features make it behave more like a native app – for example: HTML5 application cache makes it possible to access a web app without Internet connection. Web apps don’t have access to all native device features such as toggling flashlight, detecting app state changes, push notifications and so on.
Hybrid Apps: Hybrid apps are the ones that combine the best and worst elements of both native and web apps. They are written in HTML, CSS and JavaScript just like web apps so that they can be used in any platform and are wrapped inside a native app so that it can access all device features, work offline and can be installed through platform specific stores. But just like web apps they have slow performance because they are interpreted inside a native app. They also lack native look and feel just like web apps.
Each of these app types has their own advantages and disadvantages. It may sometimes seem difficult to choose between them but its not that hard to choose.

So when it comes to choosing one of these kinds of apps in the end all depends on the features of the app, graphics, and how you want to distribute the app. Even budget and time are important factors.

You should go with native app development if you are planning to create games or any other kind of app that includes high graphics and animations. Native apps are compiled therefore they are best for these kinds of apps. Although WebGL can be used by hybrid or web apps to create games but still performance wise WebGL will always be behind native code because JavaScript is interpreted and also WebGL is not supported by all mobile browsers. If you want to build cross platform mobile games and you don’t to use hybrid apps than in this case you go for game development engines like Unity 3D which let’s you build games for multiple platforms with single code base and also let’s you write game scripts using major languages such as C#, JavaScript and Python.

You should consider creating a web app if your app doesn’t depend on native a feature that is it only relays on browser APIs. For example: If you have a responsive or adaptive designed website and you want users to be able to use it as a app then you can go with web app. Converting a mobile des

C++ -> C#: What You Need to Know to Move from C++ to C#

2013-11-21T10:17:00.001+05:30

C# builds on the syntax and semantics of C++, allowing C programmers to take advantage of .NET and the common language runtime. While the transition from C++ to C# should be a smooth one, there are a few things to watch out for including changes to new, structs, constructors, and destructors. This article explores the language features that are new to C# such as garbage collection, properties, foreach loops, and interfaces. Following a discussion of interfaces, there's a discussion of properties, arrays, and the base class libraries. The article concludes with an exploration of asynchronous I/O, attributes and reflection, type discovery, and dynamic invocation.

very 10 years or so, developers must devote time and energy to learning a new set of programming skills. In the early 1980s it was Unix and C; in the early 1990s it was Windows® and C++; and today it is the Microsoft® .NET Framework and C#. While this process takes work, the benefits far outweigh the costs. The good news is that with C# and .NET the analysis and design phases of most projects are virtually unchanged from what they were with C++ and Windows. That said, there are significant differences in how you will approach programming in the new environment. In this article I'll provide information about how to make the leap from programming in C++ to programming in C#.
Many articles (for example, http://msdn.microsoft.com/msdnmag/issues/0900/csharp/csharp.asp) have explained the overall improvements that C# implements, and I won't repeat that information here. Instead, I'll focus on what I see as the most significant change when moving from C++ to C#: going from an unmanaged to a managed environment. I'll also warn you about a few significant traps awaiting the unwary C++ programmer and I'll show some of the new features of the language that will affect how you implement your programs.

Moving to a Managed Environment

      C++ was designed to be a low-level platform-neutral object-oriented programming language. C# was designed to be a somewhat higher-level component-oriented language. The move to a managed environment represents a sea change in the way you think about programming. C# is about letting go of precise control, and letting the framework help you focus on the big picture.
      For example, in C++ you have tremendous control over the creation and even the layout of your objects. You can create an object on the stack, on the heap, or even in a particular place in memory using the placement operator new.
      With the managed environment of .NET, you give up that level of control. When you choose the type of your object, the choice of where the object will be created is implicit. Simple types (ints, doubles, and longs) are always created on the stack (unless they are contained within other objects), and classes are always created on the heap. You cannot control where on the heap an object is created, you can't get its address, and you can't pin it down in a particular memory location. (There are ways around these restrictions, but they take you out of the mainstream.)
      You no longer truly control the lifetime of your object. C# has no destructor. The garbage collector will take your item's storage back sometime after there are no longer any references to it, but finalization is nondeterministic.
      The very structure of C# reflects the underlying framework. There is no multiple inheritance and there are no templates because multiple inheritance is terribly difficult to implement efficiently in a managed, garbage-collected environment, and because generics have not been implemented in the framework.
      The C# simple types are nothing more than a mapping to the underlying common language runtime (CLR) types. For example, a C# int maps to a System.Int32. The types in C# are determined not by the language, but by the common type system. In fact, if you want to preserve the ability to derive C# objects from Visual Basic® objects, you must restrict yourself further, to the common language subset—those features shared by all .NET languages.
      On the other hand, the managed environment and CLR bring a number of tangible benefits. In addition to garbage collection and a uniform type system across all .NET languages, you get a greatly enhanced component-based language, which fully supports versioning and provides extensible metadata, available at runtime through reflection. There is no need for special support for late binding; type discovery and late binding are built into the language. In C#, enums and properties are first-class members of the language, fully supported by the underlying engine, as are events and delegates (type-safe function pointers).
      The key benefit of the managed environment, however, is the .NET Framework. While the framework is available to any .NET language, C# is a language that's well-designed for programming with the framework's rich set of classes, interfaces, and objects.

Traps

C# looks a lot like C++, and while this makes the transition easy, there are some traps along the way. If you write what looks like perfectly legitimate code in C++, it won't compile, or worse, it won't behave as expected. Most of the syntactic changes from C++ to C# are trivial (no semicolon after a class declaration, Main is now capitalized). I'm building a Web page which lists these for easy reference (seehttp://www.LibertyAssociates.com and click on the FAQ for Programming C#), but most of these are easily caught by the compiler and I won't devote space to them here. I do want to point out a few significant changes that will cause problems, however.

Reference and Value Types

C# distinguishes between value types and reference types. Simple types (int, long, double, and so on) and structs are value types, while all classes are reference types, as are Objects. Value types hold their value on the stack, like variables in C++, unless they are embedded within a reference type. Reference type variables sit on the stack, but they hold the address of an object on the heap, much like pointers in C++. Value types are passed to methods by value (a copy is made), while reference types are effectively passed by reference.

Structs

Structs are significantly different in C#. In C++ a struct is exactly like a class, except that the default inheritance and default access are public rather than private. In C# structs are very different from classes. Structs in C# are designed to encapsulate lightweight objects. They are value types (not reference types), so they're passed by value. In addition, they have limitations that do not apply to classes. For example, they are sealed, which means they cannot be derived from or have any base class other than System.ValueType, which is derived from Object. Structs cannot declare a default (parameterless) constructor.
On the other hand, structs are more efficient than classes so they're perfect for the creation of lightweight objects. If you don't mind that the struct is sealed and you don't mind value semantics, using a struct may be preferable to using a class, especially for very small objects.

Everything Derives from Object

In C# everything ultimately derives from Object. This includes classes you create, as well as value types such as int or structs. The Object class offers useful methods, such as ToString. An example of when you use ToString is with the System.Console.WriteLine method, which is the C# equivalent of cout. The method is overloaded to take a string and an array of objects.
To use WriteLine you provide substitution parameters, not unlike the old-fashioned printf. Assume for a moment that myEmployee is an instance of a user-defined Employee class and myCounter is an instance of a user-defined Counter class. If you write the following code

Console.WriteLine("The employee: {0}, the counter value: {1}", 
                  myEmployee, myCounter);

WriteLine will call the virtual method Object.ToString on each of the objects, substituting the strings they return for the parameters. If the Employee class does not override ToString, the default implementation (derived from System.Object) will be called, which will return the name of the class as a string. Counter might override ToString to return an integer value. If so, the output might be:

The employee: Employee, the counter value: 12

What happens if you pass integer values to WriteLine? You can't call ToString on an integer, but the compiler will implicitly box the int in an instance of Object whose value will be set to the value of the integer. When WriteLine calls ToString, the object will return the string representation of the integer's value (see Figure 1).

Reference Parameters and Out Parameters

In C#, as in C++, a method can only have one return value. You overcome this in C++ by passing pointers or references as parameters. The called method changes the parameters, and the new values are available to the calling method.
When you pass a reference into a method, you do have access to the original object in exactly the way that passing a reference or pointer provides you access in C++. With value types, however, this does not work. If you want to pass the value type by reference, you mark the value type parameter with the ref keyword.

public void GetStats(ref int age, ref int ID, ref int yearsServed)

Note that you need to use the ref keyword in both the method declaration and the actual call to the method.

Fred.GetStats(ref age, ref ID, ref yearsServed);

You can now declare age, ID, and yearsServed in the calling method and pass them into GetStats and get back the changed values.
C# requires definite assignment, which means that the local variables, age, ID, and yearsServed must be initialized before you call GetStats. This is unnecessarily cumbersome; you're just using them to get values out of GetStats. To address this problem, C# also provides the out keyword, which indicates that you may pass in uninitialized variables and they will be passed by reference. This is a way of stating your intentions explicitly:

public void GetStats(out int age, out int ID, out int yearsServed)

Again, the calling method must match.

Fred.GetStats(out age,out ID, out yearsServed);

Calling New

In C++, the new keyword instantiates an object on the heap. Not so in C#. With reference types, the new keyword does instantiate objects on the heap, but with value types such as structs, the object is created on the stack and a constructor is called.
You can, in fact, create a struct on the stack without using new, but be careful! New initializes the object. If you don't use new, you must initialize all the values in the struct by hand before you use it (before you pass it to a method) or it won't compile. Once again, definite assignment requires that every object be initialized (see Figure 2).

Properties

      Most C++ programmers try to keep member variables private. This data hiding promotes encapsulation and allows you to change your implementation of the class without breaking the interface your clients rely on. You typically want to allow the client to get and possibly set the value of these members, however, so C++ programmers create accessor methods whose job is to modify the value of the private member variables.
      In C#, properties are first-class members of classes. To the client, a property looks like a member variable, but to the implementor of the class it looks like a method. This arrangement is perfect; it allows you total encapsulation and data hiding while giving your clients easy access to the members.
      You can provide your Employee class with an Age property to allow clients to get and set the employee's age member.

public int Age
{
    get
    {
        return age;
    }
    set
    {
        age = value;
    }
}

The keyword value is implicitly available to the property. If you write

Fred.Age = 17;

the compiler will pass in the value 17 as value.
You can create a read-only property for YearsServed by implementing the Get and not the Set accessor.

public int YearsServed
{
    get
    {
        return yearsServed;
    }
}

If you change your driver program to use these accessors, you can see how they work (see Figure 3).
You can get Fred's age through the property and then you can use that property to set the age. You can access the YearsServed property to obtain the value, but not to set it; if you uncomment the last line, the program will not compile.
If you decide later to retrieve the Employee's age from a database, you need change only the accessor implementation; the client will not be affected.

Arrays

      C# provides an array class which is a smarter version of the traditional C/C++ array. For example, it is not possible to write past the bounds of a C# array. In addition, Array has an even smarter cousin, ArrayList, which can grow dynamically to manage the changing size requirements of your program.
      Arrays in C# come in three flavors: single-dimensional, multidimensional rectangular arrays (like the C++ multidimensional arrays), and jagged arrays (arrays of arrays).
      You can create a single-dimensional array like this:

int[] myIntArray = new int[5];

Otherwise, you can initialize it like this:

int[] myIntArray = { 2, 4, 6, 8, 10 };

You can create a 4×3 rectangular array like this:

int[,] myRectangularArray = new int[rows, columns];

Alternatively, you can simply initialize it, like this:

int[,] myRectangularArray =  
{
    {0,1,2}, {3,4,5}, {6,7,8}, {9,10,11}
};

Since jagged arrays are arrays of arrays, you supply only one dimension

int[][] myJaggedArray = new int[4][];

and then create each of the internal arrays, like so:

myJaggedArray[0] = new int[5]; 
myJaggedArray[1] = new int[2]; 
myJaggedArray[2] = new int[3]; 
myJaggedArray[3] = new int[5];

Because arrays derive from the System.Array object, they come with a number of useful methods, including Sort and Reverse.

Indexers

It is possible to create your own array-like objects. For example, you might create a listbox which has a set of strings that it will display. It would be convenient to be able to access the contents of the box with an index, just as if it were an array.

string theFirstString = myListBox[0];
string theLastString = myListBox[Length-1];

This is accomplished with Indexers. An Indexer is much like a property, but supports the syntax of the index operator. Figure 4 shows a property whose name is followed by the index operator.
Figure 5 shows how to implement a very simple ListBox class and provide indexing for it.

Interfaces

      A software interface is a contract for how two types will interact. When a type publishes an interface, it tells any potential client, "I guarantee I'll support the following methods, properties, events, and indexers."
      C# is an object-oriented language, so these contracts are encapsulated in entities called interfaces. The interface keyword declares a reference type which encapsulates a contract.
      Conceptually, an interface is similar to an abstract class. The difference is that an abstract class serves as the base class for a family of derived classes, while interfaces are meant to be mixed in with other inheritance trees.

The IEnumerable Interface

      Returning to the previous example, it would be nice to be able to print the strings from the ListBoxTest class using a foreach loop, as you can with a normal array. You can accomplish this by implementing the IEnumerable interface in your class, which is used implicitly by the foreach construct. IEnumerable is implemented in any class that wants to support enumeration and foreach loops.
      IEnumerable has only one method, GetEnumerator, whose job is to return a specialized implementation of IEnumerator. Thus the semantics of an Enumerable class allow it to provide an Enumerator.
      The Enumerator must implement the IEnumerator methods. This can be implemented either directly by the container class or by a separate class. The latter approach is generally preferred because it encapsulates this responsibility in the Enumerator class rather than cluttering up the container.
      I'll add an Enumerator to the ListBoxTest that you have already seen in Figure 5. Because the Enumerator class is specific to my container class (that is, because ListBoxEnumerator must know a lot about ListBoxTest) I will make it a private implementation, contained within ListBoxTest.
      In this version, ListBoxTest is defined to implement the IEnumerable interface. The IEnumerable interface must return an Enumerator.

public IEnumerator GetEnumerator()
{
    return (IEnumerator) new ListBoxEnumerator(this);
}

Notice that the method passes the current ListBoxTest object (this) to the enumerator. That will allow the enumerator to enumerate this particular ListBoxTest object.
The class to implement the Enumerator is implemented here as ListBoxEnumerator, which is a private class defined within ListBoxTest. Its work is fairly straightforward.
The ListBoxTest to be enumerated is passed in as an argument to the constructor, where it is assigned to the member variable myLBT. The constructor also sets the member variable index to -1, indicating that enumerating the object has not yet begun.

public ListBoxEnumerator(ListBoxTest theLB)
{
    myLBT = theLB;
    index = -1;
}

The MoveNext method increments the index and then checks to ensure that you have not run past the end of the object you're enumerating. If you have, you return false; otherwise, true is returned.

public bool MoveNext()
{
    index++;
    if (index >= myLBT.myStrings.Length)
        return false;
    else
        return true;
}

Reset does nothing but reset the index to -1.
The property Current is implemented to return the last string added. This is an arbitrary decision; in other classes Current will have whatever meaning the designer decides is appropriate. However it's defined, every enumerator must be able to return the current member, as accessing the current member is what enumerators are for.

public object Current
{
    get
    {
        return(myLBT[index]);
    }
}

That's all there is to it. The call to foreach fetches the enumerator and uses it to enumerate over the array. Since foreach will display every string whether or not you've added a meaningful value, I've changed the initialization of myStrings to eight items to keep the display manageable.

myStrings = new String[8];

Using the Base Class Libraries

      To get a better sense of how C# differs from C++ and how your approach to solving problems might change, let's examine a slightly less trivial example. I'll build a class to read a large text file and display its contents on the screen. I'd like to make this a multithreaded program so that while the data is being read from the disk, I can do other work.
      In C++ you would create a thread to read the file, and another thread to do the other work. These threads would work independently, but they might need synchronization. You can do all of that in C# as well, but most of the time you won't need to write your own threading because .NET provides very powerful mechanisms for asynchronous I/O.
      The asynchronous I/O support is built into the CLR and is nearly as easy to use as the normal I/O stream classes. You start by informing the compiler that you'll be using objects from a number of System namespaces:

using System;
using System.IO;
using System.Text;

When you include System, you do not automatically include all its subsidiary namespaces, each must be explicitly included with the using keyword. Since you'll be using the I/O stream classes, you'll need System.IO, and you want System.Text to support ASCII encoding of your byte stream, as you'll see shortly.
The steps involved in writing this program are surprisingly simple because .NET will do most of the work for you. I'll use the BeginRead method of the Stream class. This method provides asynchronous I/O, reading in a buffer full of data, and then calling your callback method when the buffer is ready for you to process.
You need to pass in a byte array as the buffer and a delegate for the callback method. You'll declare both of these as private member variables of your driver class.

public class AsynchIOTester
{
    private Stream inputStream;       
    private byte[] buffer;          
    private AsyncCallback myCallBack;

The member variable inputStream is of type Stream, and it is on this object that you will call the BeginRead method, passing in the buffer as well as the delegate (myCallBack). A delegate is very much like a type-safe pointer to member function. In C#, delegates are first-class elements of the language.
.NET will call your delegated method when the byte has been filled from the file on disk so that you can process the data. While you're waiting you can do other work (in this case, incrementing an integer from 1 to 50,000, but in a production program you might be interacting with the user or doing other useful tasks).
The delegate in this case is declared to be of type AsyncCallback, which is what the BeginRead method of Stream expects. An AsyncCallback delegate is declared in the System namespace as follows:

public delegate void AsyncCallback (IAsyncResult ar);

Thus, this delegate may be associated with any method that returns void and takes an IAsyncResult interface as a parameter. The CLR will pass in the IAsyncResult interface object at runtime when the method is called; you only have to declare the method

void OnCompletedRead(IAsyncResult asyncResult)

and then to hook up the delegate in the constructor:

AsynchIOTester()
{
      •••
     myCallBack = new AsyncCallback(this.OnCompletedRead);
}

This assigns to the member variable myCallback (which was previously defined to be of type AsyncCallback) the instance of the delegate created by calling the AsyncCallback constructor and passing in the method you want to associate with the delegate.
Here's how the entire program works, step by step. In Main you create an instance of the class and tell it to run:

public static void Main()
{
    AsynchIOTester theApp = new AsynchIOTester();    
    theApp.Run();
}

The call to new fires up the constructor. In the constructor you open a file and get a Stream object back. You then allocate space in the buffer and hook up the callback mechanism.

AsynchIOTester()
{
    inputStream = File.OpenRead(@"C:\MSDN\fromCppToCS.txt");
    buffer = new byte[BUFFER_SIZE];
    myCallBack = new AsyncCallback(this.OnCompletedRead);
}

In the Run method, you call BeginRead, which will cause an asynchronous read of the file.

inputStream.BeginRead(
     buffer,             // where to put the results
     0,                  // offset
     buffer.Length,      // how many bytes (BUFFER_SIZE)
     myCallBack,         // call back delegate
     null);              // local state object

You then go on to do other work.

for (long i = 0; i < 50000; i++)        
{
    if (i%1000 == 0)
    {
        Console.WriteLine("i: {0}", i);
    }
}

When the read completes, the CLR will call the callback method.

void OnCompletedRead(IAsyncResult asyncResult)
{

The first thing you do in OnCompletedRead is find out how many bytes were read by calling the EndRead method of the Stream object, passing in the IAsyncResult interface object passed in by the common language runtime.

int bytesRead = inputStream.EndRead(asyncResult);

The result of this call to EndRead is to get back the number of bytes read. If the number is greater than zero, convert the buffer into a string and write it to the console, then call BeginRead again for another asynchronous read.

if (bytesRead > 0)
{
    String s = Encoding.ASCII.GetString(buffer, 0, bytesRead);
    Console.WriteLine(s);
    inputStream.BeginRead(buffer, 0, buffer.Length,
                          myCallBack, null);
}

Now you can do other work (in this case, counting to 50,000) while the reads are taking place, but you can handle the read data (in this case, by outputting it to the console) each time a buffer is full. The complete source code for this example, AsynchIO.cs, is available for download from the link at the top of this article.
Management of the asynchronous I/O is provided entirely by the CLR. It gets even nicer when you read over the network.

Reading a File Across the Network

In C++, reading a file across the network is a nontrivial programming exercise. .NET provides extensive support for this. In fact, reading files across the network is just another use of the standard Base Class Library Stream classes.
Start by creating an instance of the TCPListener class, to listen to a TCP/IP port (port 65000 in this case).

TCPListener tcpListener = new TCPListener(65000);

Once constructed, ask the TCPListener object to start listening.

tcpListener.Start();

Now wait for a client to request a connection.

Socket socketForClient = tcpListener.Accept();

The Accept method of the TCPListener object returns a Socket object, which represents a standard Berkeley socket interface and which is bound to a specific end point (in this case, the client). Accept is a synchronous method and will not return until it receives a connection request. If the socket is connected, you're ready to send the file to the client.

if (socketForClient.Connected)
{
•••

Next you have to create a NetworkStream class, passing the socket in to the constructor.

NetworkStream networkStream = new NetworkStream(socketForClient);

Then create a StreamWriter object much as you did before, except this time not on a file, but on the NetworkStream you just created.

System.IO.StreamWriter streamWriter = 
 new System.IO.StreamWriter(networkStream);

When you write to this stream, the stream is sent over the network to the client. The complete source code, TCPServer.cs, is also available for download.

Creating the Client

The client instantiates a TCPClient class, which represents a TCP/IP client connection to a host.

TCPClient socketForServer;
socketForServer = new TCPClient("localHost", 65000);

With this TCPClient, you can create a NetworkStream, and on that stream create a StreamReader.

NetworkStream networkStream = socketForServer.GetStream();
System.IO.StreamReader streamReader = 
    new System.IO.StreamReader(networkStream);

Now, read the stream as long as there is data on it, and output the results to the console.

do
{
    outputString = streamReader.ReadLine();

    if( outputString != null )
    {
        Console.WriteLine(outputString);
    }
}
while( outputString != null );

To test this, you create a simple test file:

This is line one
This is line two
This is line three
This is line four

Here is the output from the server:

Output (Server)
Client connected
Sending This is line one
Sending This is line two
Sending This is line three
Sending This is line four
Disconnecting from client...
Exiting...

And here is the output from the client:

This is line one
This is line two
This is line three
This is line four

Attributes and Metadata

One significant difference between C# and C++ is that C# provides inherent support for metadata: data about your classes, objects, methods, and so forth. Attributes come in two flavors: those that are supplied as part of the CLR and attributes you create for your own purposes. CLR attributes are used to support serialization, marshaling, and COM interoperability. A search of the CLR reveals a great many attributes. As you've seen, some attributes are applied to an assembly, others to a class or interface. These are called the attribute targets.
Attributes are applied to their target by placing them in square brackets immediately before the target item. Attributes may be combined, either by stacking one on top of another

[assembly: AssemblyDelaySign(false)]
[assembly: AssemblyKeyFile(".\\keyFile.snk")]

or by separating the attributes with commas.

[assembly: AssemblyDelaySign(false),
   assembly: AssemblyKeyFile(".\\keyFile.snk")]

Custom Attributes

You are free to create your own custom attributes and to use them at runtime as you see fit. For example, you might create a documentation attribute to tag sections of code with the URL of associated documentation. Or you might tag your code with code review comments or bug fix comments.
Suppose your development organization wants to keep track of bug fixes. It turns out you keep a database of all your bugs, but you'd like to tie your bug reports to specific fixes in the code. You might add comments to your code similar to the following:

// Bug 323 fixed by Jesse Liberty 1/1/2005.

This would make it easy to see in your source code, but it would be nice if you could extract this information into a report or keep it in a database so that you could search for it. It would also be nice if all the bug report notations used the same syntax. A custom attribute may be just what you need. You would then replace your comment with something like this:

[BugFix(323,"Jesse Liberty","1/1/2005") Comment="Off by one error"]

Attributes, like most things in C#, are classes. To create a custom attribute, you derive your new custom attribute class from System.Attribute.

public class BugFixAttribute : System.Attribute

You need to tell the compiler what kinds of elements this attribute can be used with (the attribute target). You specify this with (what else?) an attribute.

[AttributeUsage(AttributeTargets.ClassMembers, AllowMultiple = true)]

AttributeUsage is an attribute applied to attributes—a meta attribute. It provides, if you will, meta-metadata; that is data about the metadata. In this case, you pass two arguments: the first is the target (in this case class members) and a flag indicating whether a given element may receive more than one such attribute. AllowMultiple has been set to true, which means a class member may have more than one BugFixAttribute assigned.
If you wanted to combine Attribute targets, you can OR them together.

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface,
    AllowMultiple = true)]

This would allow the attribute to be attached to either a Class or an Interface.
The new custom attribute is named BugFixAttribute. The convention is to append the word Attribute to your attribute name. The compiler supports this by allowing you to call the attribute, when you assign it to an element, with the shorter version of the name. Thus, you can write this:

[BugFix(123, "Jesse Liberty", "01/01/05", Comment="Off by one")]

The compiler will first look for an attribute named BugFix and, not finding that, will then look for BugFixAttribute.
Every attribute must have at least one constructor. Attributes take two types of parameters, positional and named. In the previous example, the bug ID, the programmer's name, and the date were positional parameters and comment was a named parameter. Positional parameters are passed in through the constructor and must be passed in the order declared in the constructor.

public BugFixAttribute(int bugID, string programmer, string date)
{
    this.bugID = bugID;
    this.programmer = programmer;
    this.date = date;
}

Named parameters are implemented as properties.

Using the Attribute

To test the attribute, create a simple class named MyMath and give it two functions. Then assign the bug fix attributes to the class.

[BugFixAttribute(121,"Jesse Liberty","01/03/05")]

[BugFixAttribute(107,"Jesse Liberty","01/04/05", 
    Comment="Fixed off by one errors")]
public class MyMath

These attributes will be stored with the metadata. Figure 6 provides the complete source code. The following shows the output:

Calling DoFunc(7). Result: 9.3333333333333339

As you can see, the attributes had absolutely no impact on the output, and creating attributes has no impact on performance. In fact, for the moment, you have only my word that the attributes exist at all. A quick look at the metadata using ILDASM does reveal that the attributes are in place, however, as shown in Figure 7.

Reflection

For this to be useful, you need a way to access the attributes from the metadata—ideally during runtime. C# provides support for reflection for examining the metadata. Start by initializing an object of type MemberInfo. This object, in the System.Reflection namespace, is provided to discover the attributes of a member and to provide access to the metadata.

System.Reflection.MemberInfo inf = typeof(MyMath);

Call the typeof operator on the MyMath type, which returns an object of type Type, which derives from MemberInfo.
The next step is to call GetCustomAttributes on this MemberInfo object, passing in the type of the attribute you want to find. What you get back is an array of objects, each of which is of type BugFixAttribute:

object[] attributes;
attributes = Attribute.GetCustomAttributes(inf,    
    typeof(BugFixAttribute));

You can now iterate through this array, printing out the properties of the BugFixAttribute object, as shown in Figure 8. When this replacement code is put into the listing in Figure 6, the metadata is displayed.

Type Discovery

      You can use reflection to explore and examine the contents of an assembly. You'll find this particularly useful if you're building a tool which needs to display information about the assembly, or if you want to dynamically invoke methods in the assembly. You might want to do so if you're developing a scripting engine, which would allow your users to generate scripts and run them through your program.
      With reflection, you can find the types associated with a module, the methods, fields, properties, and events associated with a type, as well as the signatures of each of the type's methods, the interfaces supported by the type, and the type's superclass.
      To start, let's load an assembly dynamically with the Assembly.Load static method. The signature for this method is as follows:

public static Assembly.Load(AssemblyName)

Then you should pass in the core library.

Assembly a = Assembly.Load("Mscorlib.dll");

Once the assembly is loaded, you can call GetTypes to return an array of Type objects. The Type object is the heart of reflection. Type represents type declarations: classes, interfaces, arrays, values, and enumerations.

Type[] types = a.GetTypes();

The assembly returns an array of types that can be displayed in a foreach loop. The output from this will fill many pages. Here is a short excerpt from the output:

Type is System.TypeCode
Type is System.Security.Util.StringExpressionSet
Type is System.Text.UTF7Encoding$Encoder
Type is System.ArgIterator
Type is System.Runtime.Remoting.JITLookupTable
1205 types found

You have obtained an array filled with the types from the core library, and printed them one by one. As the output shows, the array contains 1,205 entries.

Reflecting on a Type

You can reflect on a single type in the assembly as well. To do so, you extract a type from the assembly with the GetType method.

public class Tester
{
    public static void Main()
    {
        // examine a single object
        Type theType = Type.GetType("System.Reflection.Assembly");
        Console.WriteLine("\nSingle Type is {0}\n", theType);
    }
}

The output looks like this:

Single Type is System.Reflection.Assembly

Finding the Members

You can ask this type for all its members, listing all the methods, properties, and fields, as you can see in Figure 9.
Once again the output is quite lengthy, but within the output you see fields, methods, constructors, and properties, as shown in this excerpt:

System.String s_localFilePrefix is a Field
Boolean IsDefined(System.Type) is a Method
Void .ctor() is a Constructor
System.String CodeBase  is a Property
System.String CopiedCodeBase  is a Property

Finding Only Methods

You might want to focus on only the methods, excluding the fields, properties, and so forth. To do so, you remove the call to GetMembers.

MemberInfo[] mbrInfoArray = 
    theType.GetMembers(BindingFlags.LookupAll);

Then you add a call to GetMethods.

mbrInfoArray = theType.GetMethods();

The output now is nothing but the methods.

Output (excerpt)
Boolean Equals(System.Object) is a Method
System.String ToString() is a Method
System.String CreateQualifiedName(System.String, System.String)
 is a Method
System.Reflection.MethodInfo get_EntryPoint() is a Method

Finding Particular Members

Finally, to narrow down even further, you can use the FindMembers method to find particular members of the type. For example, you can restrict your search to methods whose names begin with the letters "Get", as you can see in Figure 10.
An excerpt of the output looks like this:

System.Type[] GetTypes() is a Method
System.Type[] GetExportedTypes() is a Method
System.Type GetType(System.String, Boolean) is a Method
System.Type GetType(System.String) is a Method
System.Reflection.AssemblyName GetName(Boolean) is a Method
System.Reflection.AssemblyName GetName() is a Method
Int32 GetHashCode() is a Method
System.Reflection.Assembly GetAssembly(System.Type) is a Method
System.Type GetType(System.String, Boolean, Boolean) is a Method

Dynamic Invocation

Once you've discovered a method, it is possible to invoke it using reflection. For example, you might like to invoke the Cos method of System.Math, which returns the cosine of an angle.
To do so, you will get the Type information for the System.Math class, like so:

Type theMathType = Type.GetType("System.Math");

With that type information, you can dynamically load an instance of that class.

Object theObj = Activator.CreateInstance(theMathType);

CreateInstance is a static method of the Activator class, which can be used to instantiate objects.
With an instance of System.Math in hand, you can call the Cos method. To do so, you must prepare an array that will describe the types of the parameters. Since Cos takes a single parameter (the angle whose cosine you want) you need an array with a single member. Into that array you'll put a Type object for the System.Double type, which is the type of parameter expected by Cos.

Type[] paramTypes = new Type[1];
paramTypes[0]= Type.GetType("System.Double");

You can now pass the name of the method you want and this array describing the types of the parameters to the GetMethod method of the type object retrieved earlier.

MethodInfo CosineInfo = 
    theMathType.GetMethod("Cos",paramTypes);

You now have an object of type MethodInfo on which you can invoke the method. To do so, you must pass in the actual value of the parameters, again in an array.

Object[] parameters = new Object[1];
parameters[0] = 45;
Object returnVal = CosineInfo.Invoke(theObj,parameters);

Note that I've created two arrays. The first, paramTypes, held the type of the parameters; the second, parameters, held the actual value. If the method had taken two arguments, you would have declared these arrays to hold two values. If the method took no values, you still would create the array, but you would give it a size of zero!

Type[] paramTypes = new Type[0];

Odd as this looks, it is correct. Figure 11 shows the complete code.

Conclusion

While there are a number of subtle traps waiting for the unwary C++ programmer, the syntax of C# is not very different from C++ and the transition to the new language is fairly easy. The interesting part of working with C# is working your way through the new common language runtime library, which provides a host of functionality that previously had to be written by hand. This article could only touch on a few highlights. The CLR and the .NET Framework provide extensive support for threading, marshaling, Web application development, Windows-based application development, and so forth.
The distinction between language features and CLR features is a bit blurry at times, but the combination is a very powerful development tool.

How To Make a Wireless Network Secure???

2013-11-10T15:15:00.001+05:30

When setting up a wireless network for your small business, it can be all too tempting to leave any security functions switched off. It may seem at the time that getting work done is much more important than worrying about a threat that probably won't ever materialise.
But small businesses, like all others, need to make sure their networks are secure. After all, your customers are counting on you to keep their confidential data safe.
The thing to realise is that your wireless network doesn't only extend within your premises. Wireless technologies provide long-range connectivity that cannot be restricted to the office, which means that anyone within range of an unsecured network can gain access.
This threatens more than just allowing others to use the internet for free. It could make you vulnerable to a breach of privacy, as hackers could monitor and intercept the open packets of data whizzing between devices and the router. Passwords, financial records, customer information and private data are all fair game to the criminal.
In addition, others may use your open wireless to access the internet for illegal activity. Should this happen you could find yourself involved in legal action, so it's well worth taking the necessary steps to ensure your network is reasonably secure. So here's what you can do.

Use encryption

Possibly the most important measure you can take to protect your network is to use encryption. Virtually all routers and wireless devices offer some form of encryption, which scrambles the data transmitted to and from your router, making your network's information unreadable to outsiders.
Encrypting a network involves creating a password or passphrase that is difficult to guess. But note here that, while there are different forms of encryption available to wireless networks, not all of them are secure.
WEPThe most basic and oldest form of wireless encryption to be commonly used is WEP (Wired Equivalency Privacy), which utilises passwords using 10 to 58 digits using 0 to 9 and A to Z.
It is no longer considered secure and can be cracked in minutes by hackers using off-the-shelf hardware and software, but some older systems still only support WEP. If you have such a device, you may need to consider ditching it in favour of something else or lowering the level of security on the network.
While WEP should not be used to secure a network, it's still worth remembering that any encryption will provide more protection than none at all.
WPA and WPA2Developed to overcome the weaknesses in WEP, WPA and WPA2 (Wi-Fi Protected Access) are the encryption modes now most widely used in wireless networks.
They use both passwords and passphrases to secure networks. A password is one group of letters, numbers and characters without spaces; a passphrase is a string of grouped characters that includes spaces, such as "Th1S 1S a p@ssphr4s£". A passphrase is much harder to guess and break than a simple password.

Use a firewall

Hardware firewalls provide the first line of defence against attacks coming from outside of the network, and most routers have firewalls built into them, which check data coming into and going out and block any suspicious activity. The devices are usually set with reasonable defaults that ensure they do a decent job.
Most firewalls use packet filtering, which looks at the header of a packet to figure out its source and destination addresses. This information is compared to a set of predefined and/or user-created rules that govern whether the packet is legitimate or not, and thus whether it's to be allowed in or discarded.
Software firewalls usually run on the endpoint desktop or laptop, with the advantage of providing a better idea what network traffic is passing through the device. More than just which ports are being used and where data is going, it will know which applications are being used and can allow or block that program's ability to send and receive data.
If the software firewall isn't sure about a particular program it can ask the user what it should do before it blocks or allows traffic.

Router settings

Change the router's access name and password
It is all too easy to set up any equipment with its default settings, especially as the default admin name and password are often printed on the router itself to allow quick access and setup. This means that hackers will try these to access your network. Changing both access name and password will make it more difficult for a criminal to gain access.
Change the default network ID
Virtually all routers come with a default network ID supplied by the manufacturer. This can provide hackers with a little clue to the identity of the router and so helps them find weak spots more easily. Changing this usually means going to the router's security settings and amending the name there. Always keep a note of what the network ID is, and put that somewhere safe.
Stop your router broadcasting its network ID
When switched on, the wireless router will broadcast its network ID (or SSID). While this is useful in enabling connections between devices, once they are connected you can turn off the broadcast so the router operates in more of a stealth mode.
Enable MAC authentication for your users
You can limit who accesses your wireless network even further by only allowing certain devices to connect to it and barring the rest. Each wireless device will have a unique serial number known as a MAC address, and MAC authentication only allows access to the network from a set of addresses defined by the administrator. This prevents unauthorised devices from accessing network resources.
Create a separate wireless network for your customers.
The wireless network used by your employees should be used by them alone. If you have customers or contractors that need wireless access as well, you should consider creating a guest network. Most business-class routers allow you to do this, and it prevents outsiders from accessing your internal network assets while still allowing them connect to the internet. This virtual local area network enables employees and guests to have access while protecting your network from snoopers.

Application Lifecycle Management

2013-05-29T23:02:00.002+05:30

Application Lifecycle Management at a glance

Welcome to Application Lifecycle Management, in this series of blog posts, I will illustrate the basics of Application Lifecycle Management including its benefits, history and building blocks. We shall talk about Agile methodology in general and how Agile strategies can enrich application lifecycle management.
This first blog post sets the stage and gives you an introduction to what ALM comprises. The second part will talk about the building blocks of ALM followed by part three which will talk about the tools used for implementing ALM. Part four introduces version control strategies that will help you streamline your development process. Finally, part five will discuss productive workspaces and how ALM can counteract the illusion of control by operating as a change enabler. After this series of blog posts, you’ll be ready to explore Agile strategies in more detail and learn how you can implement these strategies with the tools that Microsoft provides.

Getting started with Application Lifecycle Management

This post is about Application Lifecycle Management (ALM) and brings together best of two worlds, Agile and ALM. We shall discuss ALM as a way to develop and release software in a coherent, integrated way, spanning all development phases, artifact types, roles and business units. Bringing ALM and Agile together and using the right tools leads to modern, efficient way of developing software. Consequently, you’ll reduce costs, boost your productivity, and accelerate your team’s collaboration. And you can make developing software a lot more fun. ALM is based on software configuration management (SCM). SCM in turn, is based on basic version control.

CSS3 Modules

2013-05-29T01:12:00.001+05:30

CSS3 Modules
CSS3 is split up into "modules".
The old specification has been split
into smaller pieces, and new ones
are also added.
Some of the most important CSS3 modules are:
• Selectors
• Box Model
• Backgrounds and Borders
• Text Effects
• 2D/3D Transformations
• Animations
• Multiple Column Layout
•User Interface

ASP.NET

2013-05-28T03:20:00.001+05:30

ASP.NET is a new ASP generation. It
is not compatible with Classic ASP,
but ASP.NET may include Classic
ASP.
ASP.NET pages are compiled, which
makes them faster than Classic
ASP.
ASP.NET has better language
support, a large set of user
controls, XML-based components,
and integrated user authentication.
ASP.NET pages have the
extension .aspx, and are normally
written in VB (Visual Basic) or C#
(C sharp).
User controls in ASP.NET can be
written in different languages,
including C++ and Java.
When a browser requests an
ASP.NET file, the ASP.NET engine
reads the file, compiles and
executes the scripts in the file, and
returns the result to the browser as
plain HTML.

HTML5 - New Elements

2013-05-27T23:07:00.000+05:30

New Elements in HTML5

The internet, and the use of the internet, has changed a lot since HTML 4.01 became a standard in 1999.

Today, several elements in HTML 4.01 are obsolete, never used, or not used the way they were intended. All those elements are removed or re-written in HTML5.

To better handle today's internet use, HTML5 also includes new elements for drawing graphics, adding media content, better page structure, better form handling, and several APIs to drag/drop elements, find Geolocation, include web storage, application cache, web workers, etc.

The New Canvas Element

New Media Elements
New Form Elements
New Semantic/Structural Elements

HTML5 offers new elements for better structure: We will discuss all these elements in next article.

The Future Of Story Creater

2013-05-27T23:03:00.001+05:30

A while ago we released a sample called Story Creator:

Video Story

It combines several technologies, such as Windows Phone, Windows Azure, WCF, and C++. It is a complete application that you can use and extend. But we're also aware of some limitations. For example, it is based on Windows Phone 7.0, not the latest Mango release. It doesn't offer too many features. However, do not worry. We don't stop here. We want to continue to improve it, and provide more features.
In this blog post, I'll outline several potential features that may come in a future release. Note I'm not promising anything here. This is just what we're trying to do.
The focuses on the next release are:
* Upgrade to Windows Phone 7.1
* Create a Windows 8 XAML version of the client application, using .NET (not C++)
* Create a Windows 8 HTML version of the client application
* Port the C++ native video encoding component (used in the worker role) to a custom WinRT component
* Add some new features, such as caption text for each photo, and secondary tiles integration with Windows Phone/Windows 8
* Fix bugs
* Refactor code
Starting from now, I'll try to write some blog posts about how we implement those new features. As soon as a sample application gets a little bigger, it is difficult to see how it works without documentations. These blog posts reflect the work I'm doing. But they may not directly reflect what the final sample application will be. In addition, I'm also learning. Ther're a lot of new technologies, and I think I still have a lot to learn about programming best practices. So bare with me if you see something that may not be a best practice. I'll be very appreciated if you can point out problems in these blog posts.
What's more, some of the blog posts may contain project attachments. These projects are NOT samples, but rather prototypes. Sometimes I'm unsure how to proceed to implement a certain feature, so I write prototypes before actually implementing it. The prototypes should in general work fine. But if you want to use them in your production code, you should check carefully to make sure they don't contain bugs, security issues, and performance is fine.
Finally, I don't know how many blog posts I will be writing. After all, this sample is a side project. Usually I can only spend my spare time on it.
If you have any suggestions, feel free to leave comments on the blog posts.