Thursday 18 October 2012

Free Airtel 3G : Working Proxy


Working proxys for Airtel free 3g :-

Home Page :fb.me
Proxy:interrobangpath.org
Port :80

Home Page: fb.me
Proxy: 176.9.126.177
Port: 80

homepage=http://fb.me
proxy=anobrowse.com
port=80

Apn: airtelgprs.com
Port: 80
Proxy: 174.142.196.230
(or)
Apn : airtelgprs.com
Port - 80
Proxy - 69.162.137.227
Homepage : fb.me or live.airtelworld.com
( or )
85.214.50.141
or
66.90.76.90 (Old but working fast)
or
176.31.222.34 (Old but working)
Homepage:  fb.me or any free site.

Facebook, YouTube and Many more Now With Free Airtel 3G


1. First Activate 3G and Balance should be less than 5.
2.change proxy settings in Firefox:
Proxy:  208.77.23.4
Port : 80
3. Change Home Page to : http://fb.me/index.php
4. open home page and Enter any URL in that page only.

Free Internet on Airtel 3G

  1. First Activate 3G and Balance should be less than 5.
  2. Change proxy settings in Firefox:
    Proxy: 150.161.2.9
    Port : 80
  3. Change Home Page to :  http;//59.160.229.40/~mgr/proxy.php
  4. Open home page and Enter any URL in that page only.

Tuesday 16 October 2012

Sliding Window Protocols using C



#include<fstream.h>
#include<stdio.h>
#include<iostream.h>
#include<conio.h>
#include<string.h>
#include<process.h>
void receiver(char a,int& flag)
{

fstream fil;
fil.open("Z:\write.txt",ios::in|ios::app);
cout<<"\nThe receive bit is :"<<a;
fil<<a;
flag=1;
fil.close();
getch();

}
void sender()
{
int flag=0;
fstream f;
f.open("Z:\send.txt",ios::in|ios::app);
char a=1;
while(!f.eof())
{
     f>>a;
     cout<<"\nsending bit is:";
     cout<<a;
     receiver(a,flag);
     if(flag==0)
     {
getch();
exit(0);
     }
     cout<<"\nacknowledgement complete NEXT BIT :\n";
     flag=0;
}
}
void main()
{
clrscr();
remove("Z:\CN\write.txt");
sender();
getch();
}

/* OUTPUT:
sending bit is:G
The receive bit is :G
acknowledgement complete NEXT BIT :

sending bit is:O
The receive bit is :O
acknowledgement complete NEXT BIT :

sending bit is:O
The receive bit is :O
acknowledgement complete NEXT BIT :

sending bit is:D
The receive bit is :D
acknowledgement complete NEXT BIT :

sending bit is:M
The receive bit is :M
acknowledgement complete NEXT BIT :

sending bit is:O
The receive bit is :O
acknowledgement complete NEXT BIT :

sending bit is:R
The receive bit is :R
acknowledgement complete NEXT BIT :

sending bit is:I
The receive bit is :I
acknowledgement complete NEXT BIT :

sending bit is:N
The receive bit is :N
acknowledgement complete NEXT BIT :

sending bit is:G
The receive bit is :G
acknowledgement complete NEXT BIT :

*/
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             
                                                                             

Socket Programming in C

Client :-


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>

#define PORT 3400 // the port client will be connecting to

#define MAXDATASIZE 100 // max number of bytes we can get at once

int main(int argc, char *argv[])
{
    int sockfd, numbytes;
    char buf[MAXDATASIZE];
    struct hostent *he;
    struct sockaddr_in their_addr; // connector's address information

    if (argc != 2) {
        fprintf(stderr,"usage: client hostname\n");
        exit(1);
    }

    if ((he=gethostbyname(argv[1])) == NULL) {  // get the host info
        perror("gethostbyname");
        exit(1);
    }

    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        perror("socket");
        exit(1);
    }

    their_addr.sin_family = AF_INET;    // host byte order
    their_addr.sin_port = htons(PORT);  // short, network byte order
    their_addr.sin_addr = *((struct in_addr *)he->h_addr);
    memset(&(their_addr.sin_zero), '\0', 8);  // zero the rest of the struct

    if (connect(sockfd, (struct sockaddr *)&their_addr, sizeof(struct sockaddr)) == -1) {
        perror("connect");
        exit(1);
    }

    if ((numbytes=recv(sockfd, buf, MAXDATASIZE-1, 0)) == -1) {
        perror("recv");
        exit(1);
    }

    buf[numbytes] = '\0';

    printf("Received: %s",buf);

    close(sockfd);

    return 0;
}

Server :-


/*erver.c -- a stream socket server demo
*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <signal.h>

#define MYPORT 3400    // the port users will be connecting to

#define BACKLOG 10     // how many pending connections queue will hold

/*void sigchld_handler(int s)
{
    while(waitpid(-1, NULL, WNOHANG) > 0);
}*/

int main(void)
{
    int sockfd, new_fd;  // listen on sock_fd, new connection on new_fd
    struct sockaddr_in my_addr;    // my address information
    struct sockaddr_in their_addr; // connector's address information
    socklen_t sin_size;
    struct sigaction sa;
    int yes=1;

    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        perror("socket");
        exit(1);
    }

  /*  if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {
        perror("setsockopt");
        exit(1);
    }*/

    my_addr.sin_family = AF_INET;         // host byte order
    my_addr.sin_port = htons(MYPORT);     // short, network byte order
    my_addr.sin_addr.s_addr = INADDR_ANY; // automatically fill with my IP
    memset(&(my_addr.sin_zero), '\0', 8); // zero the rest of the struct

    if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1) {
        perror("bind");
        exit(1);
    }

    if (listen(sockfd, BACKLOG) == -1) {
        perror("listen");
        exit(1);
    }

    /*sa.sa_handler = sigchld_handler; // reap all dead processes
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    if (sigaction(SIGCHLD, &sa, NULL) == -1) {
        perror("sigaction");
        exit(1);
    }
*/
    while(1) {  // main accept() loop
        sin_size = sizeof(struct sockaddr_in);
        if ((new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size)) == -1) {
            perror("accept");
            continue;
        }
        printf("server: got connection from %s\n",inet_ntoa(their_addr.sin_addr));
      /*  if (!fork()) { // this is the child process
            close(sockfd); // child doesn't need the listener*/
            if (send(new_fd, "Hello, world!\n", 14, 0) == -1)
                perror("send");
            close(new_fd);
            exit(0);
        //}
        close(new_fd);  // parent doesn't need this
    }

    return 0;
}