'00.'에 해당되는 글 19건

  1. 2015.03.12 XCode printf("Hello, World!");
  2. 2014.11.28 arm-llinux-gnueabi-gcc를 이용한 android C언어 크로스 컴파일
  3. 2014.07.02 [javascript] 자바 스크립트 텍스트 파일 생성 및 저장 (1)
  4. 2014.06.23 C++ Hello World
  5. 2014.03.17 [python] Google SMTP를 이용하여 E-mail 전송
  6. 2014.01.07 JAVA Applet Client for Chat Server 자바 채팅 서버 + Applet 클라이언트 소스
  7. 2014.01.06 JAVA Applet Client for Chat Server 자바 채팅 서버 + Applet 클라이언트
  8. 2014.01.06 eclipse에서 JAR 파일 생성
  9. 2014.01.05 JAVA Simple Remote access Controller 원격접속
  10. 2013.12.08 [JAVA applet] 보안 설정으로 차단된 응용 프로그램 문제 해결 방법
  11. 2013.11.20 python개발 Post MySQL Injection Tool v.01
  12. 2013.10.18 ASCII Code 아스키코드
  13. 2013.10.17 [AutoIt v3] 메크로 Intro
  14. 2013.09.04 포트 스캐너
  15. 2013.09.04 SQL Injection을 위한 자동화 도구 (개발 중)
  16. 2013.07.15 [JSP] JDBC 드라이브 설치 및 MySQL
  17. 2013.07.15 [JSP] 메모장 테스트
  18. 2013.07.15 [JSP] JSP페이지 한글 깨짐 현상
  19. 2013.06.27 컬링 컨베이션 세가지(cdecl, stdcall, fastcall)
XCode printf("Hello, World!");


MAC OX의 Xcode라는 개발도구를 이용하여 Objective-C 프로그래밍을 진행할것이다.


당연히 모든 개발 언어의 처음은 Hello world를 출력 할 것이다. “Create a new Xcode project”를 선택하여 새로운 프로젝트를 생성한다.


새로운 프로젝트를 생성하면 아래와 같이 템플릿을 선택하기 위한 창이 뜬다. 왼쪽에 OS X > Applicaion > Command Line Tool 을 선택한다.


Product Name : 개발할 제품 명 (HelloWorld)
Organizaion Name : 회사 이름
Organizaion Identifier : 회사 식별자
Bundle Identifier : 자동 생성
Language : 언어 선택 (Objectivie-C)



프로젝트 폴더 저장 위치를 선택한다.



아래와 같이 신규 프로젝트가 생성되었다. 기본적으로 Objective-C 소스는 *.m 파일에 저장되나 보다.



좌측 메뉴에서 HelloWorld > main.m 을 선택하니 아래와 같이 기본적인 Objective-C 소스가 함께 생성되어 있었다.
NSLog(@“Hello, World!”);
C언어에서 사용하는 printf가 Objective-C에서는 NSLog로 사용하는가 보다.



이제 소스도 작성되었고 build를 해야하나 바로 Product > Run 선택해도 무방하다. 처음 Build 시 developer 모드인가 창이 뜨는데 그냥 로그인하고 확인하니 "Build Succeeded"가 뜬다. 



좌측 아래 실행된 Hello, World!가 출력이 되었다.



Object-Oriented Programming, OOP


객체지향 개념을 테스트 하기 위해 MyHelloWorld 객체 생성하기


해당 프로젝트에서 File > New > File 선택한다.



OS X > Source > Cocoa Class 선택한다.



객체 클레스 이름을 작성한다.
Class : 클래스 명



저장 폴더는 이전에 생성한 프로젝트와 동일한 폴더에 저장한다. Group과 Targets은 미리 선택되어 있다.


Create를 선택하면 HelloWorld 프로젝트 내 MyHelloWorld.h와 MyHelloWorld.m 파일이 생성되어 있다.


MyHelloWorld.h를 선택하여 Hello, World!를 출력하기 위한 새로운 메소드를 생성한다.
- (void)printHello;



이제는 MyHelloWorld.h에서 명시한 메소드를 구현할 차례이다. Xcode는 사용자가 소스코드를 작성하면 사용할 유용 클레스나 함수등 출력하여 준다.


이번엔 MyHellWorld.m을 선택하여 이전에 명시한 printHello 메소드를 구현해준다. 이전에 작성한 Hello, World! 동일하게 작성하면 제대로 빌드되었는지 확인이 불가능하므로 뒤에 using OOP를 입력하여 준다.



이제 다시 HelloWorld 프로젝트 내 main.m 파일로 돌아와서 이전에 작성한 Hello, World!는 주석처리하고 새로 작성한 메소드를 작성 후 실행한다.





저작자 표시 비영리 동일 조건 변경 허락
신고

'00. > 99. ETC' 카테고리의 다른 글

XCode printf("Hello, World!");  (0) 2015.03.12
ASCII Code 아스키코드  (0) 2013.10.18

Cross compiling static C hello world for Android using arm-linux-gnueabi-gcc



sudo apt-get install gcc-arm-linux-gnueabi



#include <stdio.h>


int main(int argc, char** argv) {

   printf("hello world\n");

   return 0;

}


arm-linux-gnueabi-gcc -static -march=armv5 hi.c -o hi

arm-none-linux-gnueabi-gcc -o hello -static hello.c



adb push hi /data/hi

adb shell /data/hi



http://stackoverflow.com/questions/9324772/cross-compiling-static-c-hello-world-for-android-using-arm-linux-gnueabi-gcc


안됨-_-




Android-NDK 다운로드

http://developer.android.com/tools/sdk/ndk/index.html


7z으로 압축해제


/usr/android-ndk 로 옮김

# mv ~Document/android-ndk/ /usr/android-ndk


.bashrc 에 PATH 등록

export PATH="/usr/android-ndk:$PATH"


환경설정 재 등록

# sourc .bashrc


추가 잘되었는지 확인

# $PATH 



테스트 실행

# ndk-build


아래 메세지가 나오면 path 설정 완료

Android NDK: Could not find application project directory !    

Android NDK: Please define the NDK_PROJECT_PATH variable to point to it.    

/usr/android-ndk/build/core/build-local.mk:148: *** Android NDK: Aborting    .  Stop.



프로젝트 생성

jni 디렉토리 생성


[Android.mk]

LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) LOCAL_MODULE := hello LOCAL_SRC_FILES := hello.c include $(BUILD_EXECUTABLE)

[hello.c]

#include <stdio.h> int main() { printf("hello ARM android!\n"); return 0; }

$(BUILD_EXECUTABLE)  -> 컴파일 될 바이너리를 실행파일로

빌드 전

jni/Android.mk

jni/hello.c


# ndk-build



oneandonlyme@ubuntu:~/Documents/android-dev$ ndk-build [armeabi] Compile thumb : hello <= hello.c [armeabi] Executable : hello [armeabi] Install : hello => libs/armeabi/hell



..?



저작자 표시 비영리 동일 조건 변경 허락
신고

'00. > 01. C, C++' 카테고리의 다른 글

arm-llinux-gnueabi-gcc를 이용한 android C언어 크로스 컴파일  (0) 2014.11.28
C++ Hello World  (0) 2014.06.23
텍스트파일을 생성 후 내용저장하기
저작자 표시
신고

C++ Hello World

00./01. C, C++ 2014.06.23 20:53

C++ Hello World



 int main()

 {

         cout << "Hello World";

         return 0;

 }



저작자 표시
신고

'00. > 01. C, C++' 카테고리의 다른 글

arm-llinux-gnueabi-gcc를 이용한 android C언어 크로스 컴파일  (0) 2014.11.28
C++ Hello World  (0) 2014.06.23

Python E-mail 전송


Google SMTP를 이용하여 E-mail을 전송하는 python 스크립트


mail.py



※ 참고자료

http://www.pythonforbeginners.com/google/sending-emails-using-google

http://docs.python.org/2/library/email-examples.html


저작자 표시
신고



개발환경 : Windows 7

개발언어 : JAVA

개발도구 : Eclipse

사용도구 : APM



소스 파일 다운


Chat Server.zip



Chat Server

- Applet Clinet

src

ChatApplet.html

ChatApplet.java

ChatClient.java


- Chat Server

src

NakovChatServer.java



NakovChartServer.java


/** 

 * Nakov Chat Server 

 * (c) Svetlin Nakov, 2002 

 * http://www.nakov.com 

 * 

 * This program is an example from the book "Internet 

 * programming with Java" by Svetlin Nakov. It is freeware. 

 * For more information: http://www.nakov.com/books/inetjava/ 

 * 

 * Nakov Chat Server is multithreaded chat server. It accepts 

 * multiple clients simultaneously and serves them. Clients are 

 * able to send messages to the server. When some client sends 

 * a message to the server, the message is dispatched to all 

 * the clients connected to the server. 

 * 

 * The server consists of two components - "server core" and 

 * "client handlers". 

 * 

 * The "server core" consists of two threads: 

 *   - NakovChatServer - accepts client connections, creates 

 * client threads to handle them and starts these threads 

 *   - ServerDispatcher - waits for messages and when some 

 * message arrive sends it to all the clients connected to 

 * the server 

 * 

 * The "client handlers" consist of two threads: 

 *   - ClientListener - listens for message arrivals from the 

 * socket and forwards them to the ServerDispatcher thread 

 *   - ClientSender - sends messages to the client 

 * 

 * For each accepted client, a ClientListener and ClientSender 

 * threads are created and started. A Client object is also 

 * created to maintain the information about the client and is 

 * added to the ServerDispatcher's clients list. When some 

 * client is disconnected, is it removed from the clients list 

 * and both its ClientListener and ClientSender threads are 

 * interrupted. 

 */ 

 

import java.net.*; 

import java.io.*; 

import java.util.Vector; 

 

/** 

 * NakovChatServer class is the entry point for the server. 

 * It opens a server socket, starts the dispatcher thread and 

 * infinitely accepts client connections, creates threads for 

 * handling them and starts these threads. 

 */ 

public class NakovChatServer { 

    public static final int LISTENING_PORT = 2002; 

    public static String KEEP_ALIVE_MESSAGE = "!keep-alive"; 

    public static int CLIENT_READ_TIMEOUT = 5*60*1000; 

    private static ServerSocket mServerSocket; 

 

    private static ServerDispatcher mServerDispatcher; 

 

    public static void main(String[] args) { 

        // Start listening on the server socket 

        bindServerSocket(); 

 

        // Start the ServerDispatcher thread 

        mServerDispatcher = new ServerDispatcher(); 

        mServerDispatcher.start(); 

 

        // Infinitely accept and handle client connections 

        handleClientConnections(); 

    } 

 

    private static void bindServerSocket() { 

        try { 

            mServerSocket = new ServerSocket(LISTENING_PORT); 

            System.out.println("NakovChatServer started on " + 

                "port " + LISTENING_PORT); 

        } catch (IOException ioe) { 

            System.err.println("Can not start listening on " + 

                "port " + LISTENING_PORT); 

            ioe.printStackTrace(); 

            System.exit(-1); 

        } 

    } 

 

    private static void handleClientConnections() { 

        while (true) { 

            try { 

                Socket socket = mServerSocket.accept(); 

                Client client = new Client(); 

                client.mSocket = socket; 

                ClientListener clientListener = new 

                    ClientListener(client, mServerDispatcher); 

                ClientSender clientSender = 

                    new ClientSender(client, mServerDispatcher); 

                client.mClientListener = clientListener; 

                clientListener.start(); 

                client.mClientSender = clientSender; 

                clientSender.start(); 

                mServerDispatcher.addClient(client); 

            } catch (IOException ioe) { 

                ioe.printStackTrace(); 

            } 

        } 

    } 

 

 

/** 

 * ServerDispatcher class is purposed to listen for messages 

 * received from the clients and to dispatch them to all the 

 * clients connected to the chat server. 

 */ 

class ServerDispatcher extends Thread { 

    private Vector mMessageQueue = new Vector(); 

    private Vector mClients = new Vector(); 

 

    /** 

     * Adds given client to the server's client list. 

     */ 

    public synchronized void addClient(Client aClient) { 

        mClients.add(aClient); 

    } 

 

    /** 

     * Deletes given client from the server's client list if 

     * the client is in the list. 

     */ 

    public synchronized void deleteClient(Client aClient) { 

        int clientIndex = mClients.indexOf(aClient); 

        if (clientIndex != -1) 

            mClients.removeElementAt(clientIndex); 

    } 

 

    /** 

     * Adds given message to the dispatcher's message queue and 

     * notifies this thread to wake up the message queue reader 

     * (getNextMessageFromQueue method). dispatchMessage method 

     * is called by other threads (ClientListener) when a 

     * message is arrived. 

     */ 

    public synchronized void dispatchMessage( 

            Client aClient, String aMessage) { 

        Socket socket = aClient.mSocket; 

        String senderIP = 

            socket.getInetAddress().getHostAddress(); 

        String senderPort = "" + socket.getPort(); 

        aMessage = senderIP + ":" + senderPort + 

            " : " + aMessage; 

        mMessageQueue.add(aMessage); 

        notify(); 

    } 

 

    /** 

     * @return and deletes the next message from the message 

     * queue. If there is no messages in the queue, falls in 

     * sleep until notified by dispatchMessage method. 

     */ 

    private synchronized String getNextMessageFromQueue() 

    throws InterruptedException { 

        while (mMessageQueue.size()==0) 

            wait(); 

        String message = (String) mMessageQueue.get(0); 

        mMessageQueue.removeElementAt(0); 

        return message; 

    } 

 

    /** 

     * Sends given message to all clients in the client list. 

     * Actually the message is added to the client sender 

     * thread's message queue and this client sender thread 

     * is notified to process it. 

     */ 

    private void sendMessageToAllClients( 

            String aMessage) { 

        for (int i=0; i<mClients.size(); i++) { 

            Client client = (Client) mClients.get(i); 

            client.mClientSender.sendMessage(aMessage); 

        } 

    } 

 

    /** 

     * Infinitely reads messages from the queue and dispatches 

     * them to all clients connected to the server. 

     */ 

    public void run() { 

        try { 

            while (true) { 

                String message = getNextMessageFromQueue(); 

                sendMessageToAllClients(message); 

            } 

        } catch (InterruptedException ie) { 

            // Thread interrupted. Stop its execution 

        } 

    } 

 

 

/** 

 * Client class contains information about a client, 

 * connected to the server. 

 */ 

class Client { 

    public Socket mSocket = null; 

    public ClientListener mClientListener = null; 

    public ClientSender mClientSender = null; 

 

 

/** 

 * ClientListener class listens for client messages and 

 * forwards them to ServerDispatcher. 

 */ 

class ClientListener extends Thread { 

    private ServerDispatcher mServerDispatcher; 

    private Client mClient; 

    private BufferedReader mSocketReader; 

 

    public ClientListener(Client aClient, ServerDispatcher 

            aSrvDispatcher) throws IOException { 

        mClient = aClient; 

        mServerDispatcher = aSrvDispatcher; 

        Socket socket = aClient.mSocket; 

        socket.setSoTimeout( 

            NakovChatServer.CLIENT_READ_TIMEOUT); 

        mSocketReader = new BufferedReader( 

            new InputStreamReader(socket.getInputStream()) ); 

    } 

 

    /** 

     * Until interrupted, reads messages from the client 

     * socket, forwards them to the server dispatcher's 

     * queue and notifies the server dispatcher. 

     */ 

    public void run() { 

        try { 

            while (!isInterrupted()) { 

                try { 

                    String message = mSocketReader.readLine(); 

                    if (message == null) 

                        break; 

                    mServerDispatcher.dispatchMessage( 

                        mClient, message); 

                } catch (SocketTimeoutException ste) { 

                    mClient.mClientSender.sendKeepAlive(); 

                } 

            } 

        } catch (IOException ioex) { 

            // Problem reading from socket (broken connection) 

        } 

 

        // Communication is broken. Interrupt both listener and 

        // sender threads 

        mClient.mClientSender.interrupt(); 

        mServerDispatcher.deleteClient(mClient); 

    } 

 

/** 

 * Sends messages to the client. Messages waiting to be sent 

 * are stored in a message queue. When the queue is empty, 

 * ClientSender falls in sleep until a new message is arrived 

 * in the queue. When the queue is not empty, ClientSender 

 * sends the messages from the queue to the client socket. 

 */ 

class ClientSender extends Thread { 

    private Vector mMessageQueue = new Vector(); 

 

    private ServerDispatcher mServerDispatcher; 

    private Client mClient; 

    private PrintWriter mOut; 

 

    public ClientSender(Client aClient, ServerDispatcher 

            aServerDispatcher) throws IOException { 

        mClient = aClient; 

        mServerDispatcher = aServerDispatcher; 

        Socket socket = aClient.mSocket; 

        mOut = new PrintWriter( 

            new OutputStreamWriter(socket.getOutputStream()) ); 

    } 

 

    /** 

     * Adds given message to the message queue and notifies 

     * this thread (actually getNextMessageFromQueue method) 

     * that a message is arrived. sendMessage is always called 

     * by other threads (ServerDispatcher). 

     */ 

    public synchronized void sendMessage(String aMessage) { 

        mMessageQueue.add(aMessage); 

        notify(); 

    } 

 

    /** 

     * Sends a keep-alive message to the client to check if 

     * it is still alive. This method is called when the client 

     * is inactive too long to prevent serving dead clients. 

     */ 

    public void sendKeepAlive() { 

        sendMessage(NakovChatServer.KEEP_ALIVE_MESSAGE); 

    } 

 

    /** 

     * @return and deletes the next message from the message 

     * queue. If the queue is empty, falls in sleep until 

     * notified for message arrival by sendMessage method. 

     */ 

    private synchronized String getNextMessageFromQueue() 

            throws InterruptedException { 

        while (mMessageQueue.size()==0) 

            wait(); 

        String message = (String) mMessageQueue.get(0); 

        mMessageQueue.removeElementAt(0); 

        return message; 

    } 

 

    /** 

     * Sends given message to the client's socket. 

     */ 

    private void sendMessageToClient(String aMessage) { 

        mOut.println(aMessage); 

        mOut.flush(); 

    } 

 

    /** 

     * Until interrupted, reads messages from the message queue 

     * and sends them to the client's socket. 

     */ 

    public void run() { 

        try { 

            while (!isInterrupted()) { 

                String message = getNextMessageFromQueue(); 

                sendMessageToClient(message); 

            } 

        } catch (Exception e) { 

            // Commuication problem 

        } 

 

        // Communication is broken. Interrupt both listener 

        // and sender threads 

        mClient.mClientListener.interrupt(); 

        mServerDispatcher.deleteClient(mClient); 

    } 

}







CharApplet.java


/**

 * Chat applet client for Nakov Chat Server.

 * Author: Nikolay Nedyalkov, 2002

 *

 * ChatApplet class provides applet-based graphical user interface

 * for the clients of NakovChatServer.

 */

import java.awt.*;

import java.awt.event.*;

import java.applet.*;

import java.util.Vector;

import java.util.Enumeration;

 

public class ChatApplet extends Applet implements ActionListener, MouseListener {

     boolean isStandalone = false;

 

     private ChatClient cl           = new ChatClient (this);

     private PopupMenu popupMenu1    = new PopupMenu ();

     private MenuItem menuItem1      = new MenuItem ();

     private MenuItem menuItem2      = new MenuItem ();

     private Vector allUsers         = new Vector ();

     private Vector deniedUsers      = new Vector ();

     private boolean isConnected     = false;

 

     private TextField textField1    = new TextField();

     private Button connectButton    = new Button ();

     private Button disconnectButton = new Button ();

     private Button sendButton       = new Button ();

     private Button clearButton      = new Button ();

     private Button exitButton       = new Button ();

 

     public TextArea textArea1      = new TextArea();

     public List list1              = new List();

 

     public void setConnected(boolean aConnected) {

          isConnected = aConnected;

     }

 

     public boolean getConnected()   {

          return isConnected;

     }

 

     /**

      * Method is called from ChatClient to get reference to ChatApplet.textArea1.

      * @return java.awt.TextArea

      */

     public TextArea getTextArea () {

          return textArea1;

     }

 

     /**

      * Method is called from ChatClient to get reference to ChatApplet.list1.

      * @return java.awt.List

      */

     public List getList () {

          return list1;

     }

 

     /**

      * Method is called from ChatClient to register anUser in allUsers vector

      * and list1 visual control.

      * @param anUser - user to be included.

      */

     public synchronized void addUser (String anUser) {

          if (!allUsers.contains(anUser)) {

               allUsers.addElement (anUser);

               list1.add (anUser);

          }

     }

 

     /**

      * Method is called from ChatClient to append given message to the

      * ChatApplet's TextArea. It also checks whether anUser is in our

      * Ignore list and ignores the message in this case.

      * @param anUser - user that have sent the message

      * @param aText - message to be appened to the applet's TextArea

      */

     public synchronized void addText (String aText, String anUser) {

          if (!deniedUsers.contains(anUser)) {

               textArea1.append (aText + "\n");

          }

     }

 

     public synchronized void addSystemMessage(String aText) {

          textArea1.append(aText + "\n");

     }

 

     /**

      * Applet life cycle initiliazation.

      */

     public void init() {

          try {

               jbInit();

          }

          catch(Exception e) {

               e.printStackTrace();

          }

     }

 

     /**

      * Component initialization.

      * @throws Exception

      */

     private void jbInit() throws Exception {

          this.setLayout (null);

 

          // -- Begin buttons section

          sendButton.setLabel("Send");

          sendButton.setBounds (new Rectangle(316, 245, 68, 23));

          sendButton.addActionListener (this);

          this.add(sendButton);

 

          connectButton.setLabel("connect");

          connectButton.setBounds(new Rectangle(34, 270, 95, 22));

          connectButton.addActionListener(this);

          this.add(connectButton, null);

 

          disconnectButton.addActionListener(this);

          disconnectButton.setBounds(new Rectangle(175, 270, 108, 22));

          disconnectButton.setLabel("disconnect");

          this.add(disconnectButton, null);

 

          clearButton.setLabel("Clear");

          clearButton.addActionListener(this);

          clearButton.setBounds(new Rectangle(316, 270, 68, 23));

          this.add(clearButton, null);

 

          exitButton.setBackground(Color.gray);

          exitButton.setForeground(Color.lightGray);

          exitButton.setLabel("Q");

          exitButton.setBounds(new Rectangle(388, 245, 32, 48));

          exitButton.addActionListener(this);

          this.add(exitButton, null);

          // -- End buttons section

 

          // -- Begin edit controls

          textField1.setBounds(new Rectangle(10, 245, 303, 23));

          textField1.addActionListener(this);

          textField1.setBackground(Color.lightGray);

          this.add(textField1, null);

 

          textArea1.setBounds(new Rectangle(10, 10, 303, 233));

          textArea1.setBackground(Color.lightGray);

          this.add(textArea1, null);

          // -- End edit controls

 

          // -- Begin menus section

          popupMenu1.setLabel("User menu");

          menuItem1.setLabel("Ignore user");

          menuItem1.setActionCommand ("BAN");

          menuItem1.addActionListener (this);

          menuItem2.setLabel("Deignore user");

          menuItem2.setActionCommand ("UNBAN");

          menuItem2.addActionListener (this);

          popupMenu1.add(menuItem1);

          popupMenu1.addSeparator();

          popupMenu1.add(menuItem2);

          // -- End menus section

 

          list1.setBounds(new Rectangle(316, 11, 104, 233));

          list1.add (popupMenu1);

          list1.addActionListener (this);

          list1.addMouseListener (this);

          list1.setBackground(Color.lightGray);

          this.add (popupMenu1);

          this.add(list1, null);

 

          this.setBackground(Color.cyan);

     }

 

     /**

      * Method sends aMessage to server through ChatClient.

      * @param aMessage

      */

     public void sendMessage (String aMessage) {

          cl.getOutput().println (aMessage);

          cl.getOutput().flush();

     }

 

     /**

      * Method handles ActionEvent event, registered by "this" Action listener.

      * @param ae - ActionEvent which we used to indicate "sender".

      */

     public void actionPerformed (ActionEvent ae) {

 

          if (ae.getSource().equals(textField1)) {

// catch ActionEvents coming from textField1

               sendButtonPressed();

          } else if (ae.getSource().equals(connectButton)) {

// catch ActionEvents coming connect button from textField1

               if (!isConnected) {

                    addSystemMessage("Connecting...");

                    isConnected = cl.connect();

               } else {

                    addSystemMessage("Already connected.");

               }

          } else if (ae.getSource().equals(sendButton)) {

// catch ActionEvents coming send button from textField1

               sendButtonPressed();

          } else if (ae.getSource().equals(menuItem1)) {

// catch ActionEvents comming from popupMenu->menuItem1->"Ignore"

               String selectedUser = list1.getSelectedItem();

               deniedUsers.addElement (selectedUser);

               addSystemMessage("User added to ban list.");

          } else if (ae.getSource().equals(menuItem2)) {

// catch ActionEvents comming from popupMenu->menuItem1->"Deignore"

               String selectedUser = list1.getSelectedItem();

               if (!deniedUsers.removeElement (selectedUser))

                    addSystemMessage("No such user in ban list.");

               else

                    addSystemMessage("User removed from ban list.");

          } else if (ae.getSource().equals(clearButton)) {

// catch ActionEvents comming from clear button

               textArea1.setText("");

          } else if (ae.getSource().equals(disconnectButton)) {

// catch ActionEvents comming from disconnect button

               cl.disconnect();

          } else if (ae.getSource().equals(exitButton)) {

// catch ActionEvents comming from exit button

               System.exit(0);

          }

     }

 

     private void sendButtonPressed() {

          if (!isConnected) {

               textArea1.append("Please connect first.\n");

               return;

          }

          String text = textField1.getText();

          if (text.equals(""))

               return;

          sendMessage (text);

          textField1.setText ("");

     }

 

     public void mouseClicked(MouseEvent e) {}

     public void mouseReleased(MouseEvent e) {}

     public void mouseEntered(MouseEvent e) {}

     public void mouseExited(MouseEvent e) {}

 

     /**

      * Method handles mousePressed event, registered by "this" MouseListener.

      * @param e MouseEvent

      */

     public void mousePressed(MouseEvent e) {

          // register when user pressed right mouse button

          // - e.getModifiers()==e.BUTTON3_MASK -

          // and when is "mouse down" - e.MOUSE_PRESSED==501.

          if ((e.getModifiers()==e.BUTTON3_MASK)&&(e.MOUSE_PRESSED==501)) {

               popupMenu1.show (list1, e.getX(), e.getY());

          }

     }

 

}







ChatClient.java


/**

 * Chat applet client for Nakov Chat Server.

 * Author: Nikolay Nedyalkov, 2002

 *

 * ChatClient class handles the communication with the chat server.

 */

import java.io.*;

import java.net.*;

import java.awt.*;

import java.awt.event.*;

import java.applet.*;

import java.util.Hashtable;

 

public class ChatClient

{

     public static final int SERVER_PORT = 2002;

 

     private Socket m_Socket = null;

     private BufferedReader in = null;

     private PrintWriter out = null;

     private ChatApplet m_Applet;

 

     /**

      * Constructor initialize ChatClient and sets ChatApplet refferences.

      */

     public ChatClient (ChatApplet anApplet) {

          this.m_Applet = anApplet;

     }

 

     /**

      * Method is called from ChatApplet.

      * @return PrintWriter reference to server connection.

      */

     public PrintWriter getOutput () {

          return out;

     }

 

     /**

      * Method is called from ChatApplet.

      * @return BufferedReader reference to server connection.

      */

     public BufferedReader getInput () {

          return in;

     }

 

     /**

      * Method is called from ChatApplet to establish connection to NakovChatServer.

      * In case of the applet is started locally from a file (not from a web server),

      * "localhost" is used as taget server, otherwise getCodeBase().getHost() is used.

      */

     public boolean connect () {

          boolean successfull = true;

          String serverHost = m_Applet.getCodeBase().getHost();

          if (serverHost.length()==0) {

               m_Applet.addSystemMessage("Warning: Applet is loaded from a local file,");

               m_Applet.addSystemMessage("not from a web server. Web browser's security");

               m_Applet.addSystemMessage("will probably disable socket connections.");

               serverHost = "localhost";

          }

          try {

               m_Socket = new Socket(serverHost, SERVER_PORT);

               in = new BufferedReader(

                    new InputStreamReader(m_Socket.getInputStream()));

               out = new PrintWriter(

                    new OutputStreamWriter(m_Socket.getOutputStream()));

               m_Applet.addSystemMessage("Connected to server " +

                  serverHost + ":" + SERVER_PORT);

          } catch (SecurityException se) {

               m_Applet.addSystemMessage("Security policy does not allow " +

                    "connection to " + serverHost + ":" + SERVER_PORT);

               successfull = false;

          } catch (IOException e) {

               m_Applet.addSystemMessage("Can not establish connection to " +

                    serverHost + ":" + SERVER_PORT);

               successfull = false;

          }

 

          // Create and start Listener thread

          Listener listener = new Listener(m_Applet, in);

          listener.setDaemon(true);

          listener.start();

 

          return successfull;

     }

 

     public void disconnect() {

          if (!m_Applet.getConnected()) {

               m_Applet.addSystemMessage("Can not disconnect. Not connected.");

               return;

          }

          m_Applet.setConnected(false);

          try {

               m_Socket.close();

          } catch (IOException ioe) {

          }

          m_Applet.addSystemMessage("Disconnected.");

     }

 

     /**

      * Listener class - thread is used for receiving data that comes from

      * the server and then "forward" it to ChatApplet.

      */

     class Listener extends Thread

     {

          private BufferedReader mIn;

          private ChatApplet mCA;

 

          /**

           * Constructor initiliaze InputStream, and ChatApplet reference

           * @param aCA - ChatApplet reference

           * @param aIn - InputStream from server connection

           */

          public Listener (ChatApplet aCA, BufferedReader aIn) {

               mCA = aCA;

               mIn  = aIn;

          }

 

          public void run() {

               try {

                    while (!isInterrupted()) {

                         String message = mIn.readLine();

                         int colon2index = message.indexOf(":",message.indexOf(":")+1);

                         String user = message.substring(0, colon2index-1);

                         mCA.addText (message, user);

                         mCA.addUser (user);

                    }

               } catch (Exception ioe) {

                    if (m_Applet.getConnected())

                         m_Applet.addSystemMessage("Communication error.");

               }

               m_Applet.setConnected(false);

          }

     }

}







ChatApplet.html


<html>

 

<head>

     <meta http-equiv="Content-Type" content="text/html; charset=windows-1251">

     <title>Chat Applet</title>

</head>

 

<body>

 

     ChatApplet will appear below in a Java enabled browser.<br>

 

     <applet

       codebase = "."

       code     = "ChatApplet.class"

       name     = "TestApplet"

       width    = "430"

       height   = "300"

       hspace   = "0"

       vspace   = "0"

       align    = "middle"

     >

     </applet>

    

</body>

 

</html>





출처 : http://www.nakov.com

저작자 표시
신고



개발환경 : Windows 7

개발언어 : JAVA

개발도구 : Eclipse

사용도구 : APM



실행 파일 다운 : 

Chat Server.zip



* Chat Server

- ChatApplet.class : Chat Client 구동 class 파일 (1/3)

- ChatApplet.html : 외부 접속 웹 페이지

- ChatClient$Listener.class : Chat Client 구동 class 파일 (2/3)

- ChatClient.class : Chat Client 구동 class 파일 (3/3)

- java.policy.applet : Chat Client 실행 환경

- NakovChatServer.jar : Chat Server 구동 jar 파일




1. 서버 실행

> java -jar NakovChatServer.jar




2. Chat Client 구동 Class 파일들을 웹 서버에 탑재

 ChatApplet.class, ChatApplet.html, ChatClient$Listener.class,

 ChatClient.class, java.policy.applet





3. 외부 웹 페이지 접속




4. Applet 실행




5. 보안 경고 무시





6. Connect 클릭 (연결) - 연결 정보 확인 - 대화


저작자 표시
신고


Eclipse

Jar 파일 성생







프로젝트 선택 - 오른쪽 우클릭 - Export 선택





Export 화면 - Java - Runnable JAR file 선택








Launch Configuration - 해당 프로젝트선택

Export Destination - 경로 및 파일(jar) 이름 (직접 입력)





JAR 생성 확인 (경로를 해당 프로젝트 디렉토리로 설정함)





실행


저작자 표시
신고

개발환경 : Windows7

개발언어 : JAVA

개발도구 : Eclipse


개발 기간 : 2011.03 ~ 2011.06


JAVA를 사용한 원격제어 프로그램

Remote Access Control src.zip




서버와 클라이언트 간의 네트워크 연결

이미지는 UDP를 이용하여서 전송

REFRESH Keyboard & Mouse TCP를 이용하여 전송

REFRESH, KEYBOARD MOUSE MOTION TCP데이터의 임의의 프로토콜을 제정







Server 구성도

ServerMain에서 서버의 IP를 받아서 Server 개체를 생성할 때 IP를 알려주면 Server Client가 접속 할 때까지 대기

Client가 접속하면 클라이언트의 명령에 때라서 그에 맞는 행동을 실행



Client 구성도


클라이언트는 실행 시 서버의 주소를 입력

입력 받은 서버 주소를 이용하여 서버에 접속하고 SendRefresh 클레스를 이용하여 일정 시간마다 자동으로 이미지를 갱신 시키는 명령어를 전송

또한, GUI에서 mouse keyboard 입력을 받으면 그에 맞는 클레스를 불러와 Server에 전달







저작자 표시
신고






[응용 프로그램 차단됨]

보안 설정으로 차단된 응용 프로그램



JAVA applet 테스트 중 발생된 문제로 정상적으로 applet 실행이 안되는 문제 발생.






[응용 프로그램 차단됨] 팝업 창의 확인을 클릭 시 "오류입니다. 자세한 내용을 보려면 누르십시오. 메시지와 함께 실행이 불가능하다.





  • 문제 해결 방안
    • JAVA를 최신버전으로 업데이트 - [실패]
    • Windows 7에 설치되어있는 JAVA의 보안 설정 레벨 변경 - [성공]















저작자 표시
신고

Post MySQL Injection Tool v.01


mysqlhack_post.py




저작자 표시
신고


ASCII Code

아스키코드




저작자 표시
신고

'00. > 99. ETC' 카테고리의 다른 글

XCode printf("Hello, World!");  (0) 2015.03.12
ASCII Code 아스키코드  (0) 2013.10.18

Macros

  • 매크로 프로그램 중 가장 많이 쓰이는 두가지 스크립트 언어 AutoItv3와 AutoHotKey 중 하나.
  • http://www.autoitscript.com/site/autoit/




+) 추가 

  • 이미지를 찾아 좌표를 알려주는 스크립트
  • ImageSearchDLL.dll -> C:\Windows
  • ImageSearch.au3 -> C:\Program Files\AutoIt3\Include


ImageSearch.zip



저작자 표시
신고

'00. > 07. Mecro' 카테고리의 다른 글

[AutoIt v3] 메크로 Intro  (0) 2013.10.17

포트 스캐너

00./04. Python 2013.09.04 15:00

포트 스캐너



 개발 언어

 Python 

 버 전 

 v0.1 

 기 타

 nmap 사용이 더 용이함






import optparse

from socket import *

from threading import *

screenLock = Semaphore(value=1)

def connScan(tgtHost, tgtPort):

    try:

        connSkt = socket(AF_INET, SOCK_STREAM)

        connSkt.connect((tgtHost, tgtPort))

        connSkt.send('ViolentPython\r\n')

        results = connSkt.recv(100)

        screenLock.acquire()

        print '[+]%d/tcp open'%tgtport

        print '[+] ' + str(results)

    except:

        screenLock.acquire()

        print '[-]%d/tcp closed'% tgtPort

    finally:

        screenLock.release()

        connSkt.close()

def portScan(tgtHost, tgtPorts):

    try:

        tgtIP = gethostbyname(tgtHost)

    except:

        print "[-] Cannot resolve '%s': Unknown host"%tgtHost

        return

    try:

        tgtName = gethostbyaddr(tgtIP)

        print '\n[+] Scan Results for: ' + tgtName[0]

    except:

        print '\n[+] Scan Results for: ' + tgtIP

    setdefaulttimeout(1)

    for tgtPort in tgtPorts:

        t = Thread(target=connScan, args=(tgtHost, int(tgtPort)))

        t.start()

def main():

    parser = optparse.OptionParser('usage%prog -H <target host> -p <target port>')

    parser.add_option('-H', dest='tgtHost', type='string', help='specify target host')

    parser.add_option('-p', dest='tgtPort', type='string', help='specify target port[s] separated by cmma')

    (options, args) = parser.parse_args()

    tgtHost = options.tgtHost

    tgtPorts = str(options.tgtPort).split(',')

    if(tgtHost == None) | (tgtPorts[0] == None):

        print parser.usage

        exit(0)

    portScan(tgtHost, tgtPorts)

if __name__ =='__main__':

    main()



저작자 표시
신고

SQL Injection 공격의 취약성을 쉽게 발견하기 위한 자동화 도구


 개발 언어

 Python 

 버전

 v0.1

 기타

 개발 단계 



특정 파라미터에 다양한 특수 문자를 삽입하여 HTTP 패킷을 해당 공격 서버에 전송한다.

응답 받은 HTTP 패킷의 코드번호가 200인지 500인지 확인한다.


Method : Get 방식

특수 문자 : text 파일에 개별 저장




import sys

import urllib2


fileNM = "C:\Users\User\Desktop\quarry.txt"



addr = "http://10.1.1.3:10001"

vuln = "/db_p/board/list.php"


para = "b_name"


quarryList = []



def helpFunc():

    print '[+] Usage : python sqlInjectionGet [option]\n\n'

    exit()


def sqlInjection():

fop = open(fileNM, 'r')

for line in fop:

line = line.strip()

quarryList.append(line)

fop.close()


c = 0

while c < len(quarryList):

   url = addr + vuln + "?" + para + "=" + quarryList[c]

   response = urllib2.urlopen(url)

   response = response.read()

   response = response.find('500')

   if int(response)<0:

       print "200 correct"

   else:

       print "500 Error"

   c = c + 1




def main():

    if len(sys.argv) < 2:

        print '[-] How to use this python program. help -h '

        exit()

    elif sys.argv[1]=="-h":

        helpFunc()

        

    elif sys.argv[1]=="-I":

        sqlInjection()

        

    else:

        exit()

        


if __name__ == '__main__':

    main()

 




저작자 표시
신고

JDBC 드라이브 설치 및 Mysql 연동



Apache Tomcat/7.0.42 버전


Mysql 설치




Mysql 웹 페이지

www.mysql.com/downloads/




JDBC 다운

mysql-connector-java-버전.zip





JDBC 압축 풀기





JDBC 드라이브 lib폴더에 옮기기.

1. mysql-connector-java-버전-bin.jar -> Tomcat\lib\


2. mysql-connector-java-버전-bin.jar -> java\jre\ext\




드라이브 테스트






연동 테스트할 java파일



1. java파일 컴파일


2. 실행








저작자 표시
신고

'00. > 03. Web Language' 카테고리의 다른 글

[JSP] JDBC 드라이브 설치 및 MySQL  (0) 2013.07.15
[JSP] 메모장 테스트  (0) 2013.07.15
[JSP] JSP페이지 한글 깨짐 현상  (0) 2013.07.15

메모장 테스트


<HTML>

<BODY>

<h2>메모장</h2>

<FORM METHOD=POST ACTION="ImplicitExample3.jsp">

성명 : <INPUT TYPE="text" NAME="name"><p>

메모 : <INPUT TYPE="text" NAME="memo" SIZE="40"><p>

<INPUT TYPE="submit" VALUE="입력">

<INPUT TYPE="reset" VALUE="다시쓰기">

</FORM>

</BODY>

</HTML>





 <%@ page contentType="text/html;charset=EUC-KR" 

         import="java.util.*"

 %>

 <%

    request.setCharacterEncoding("euc-kr");

  String name = request.getParameter("name");

  String memo = request.getParameter("memo");

  Date date = new Date();

 %>

 <h2>메모장</h2>

 <table border="1">

  <tr>

   <td>성명</td>

   <td><%=name%></td>

  </tr>

  <tr>

   <td>메모</td>

   <td><%=memo%></td>

  </tr>

  <tr>

   <td>날짜</td>

   <td><%=date.toLocaleString()%></td>

  </tr>

 </table> 



 

저작자 표시
신고

'00. > 03. Web Language' 카테고리의 다른 글

[JSP] JDBC 드라이브 설치 및 MySQL  (0) 2013.07.15
[JSP] 메모장 테스트  (0) 2013.07.15
[JSP] JSP페이지 한글 깨짐 현상  (0) 2013.07.15

JSP페이지 한글 깨짐 현상



1. html에서 jsp로 파라미터값이 한글일때(특히GET) 해결방법입니다.

tomcat에 있는server.xml 을 편집기로 열어 다음과 같이 빨간색 부분을 추가합니다.

<Connector port="8080" protocol="HTTP/1.1" 

connectionTimeout="20000" 

redirectPort="8443"

URIEncoding="UTF-8">

<Connector port="8009" protocol="AJP/1.3" redirectPort="8443"

URIEncoding="EUC-KR"/> 










2. 기본적으로 jsp페이지에서는 다음과 같이 코딩합니다.

1. 모든 페이지 상단

<%@ page contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>

2. Request 값이 있는 경우

request.setCharacterEncoding("UTF-8");

3. Response 문자 코드 세팅

response.setContentType("text/html; charset=UTF-8");

4. 웹서버, DB서버 캐릭터셋 확인 !!



3. HTML페이지에서 한글깨짐 발생시

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />




저작자 표시
신고

'00. > 03. Web Language' 카테고리의 다른 글

[JSP] JDBC 드라이브 설치 및 MySQL  (0) 2013.07.15
[JSP] 메모장 테스트  (0) 2013.07.15
[JSP] JSP페이지 한글 깨짐 현상  (0) 2013.07.15

# 함수 호출시에 사용한 매개변수를 정리하는 세가지 방법 


- 함수가 종료 된 후에 호출시 사용한 매개변수를 저장한 스택 위치를 정리해 주는 방법으로 esp의

위치를 함수 호출이 일어나기 전의 위치를 옮겨 주는 것


1. __cdecl

  - c/c++에서 디폴트로 사용

  - 함수 호출 시 매개변수가 제일 우측에서 좌측 순서로 스택에 쌓인다

  - 함수를 호출한 부모함수측에서 스택을 정리해 준다.([add esp, 숫자]의 형태로 표현)


2. __stdcall

  - Windows API 에서 사용

  - 함수 호출 시 매개변수가 제일 우측에서 좌측 순서로 스택에 쌓인다

  - 호출당한 자함수측에서 스택을 정리 해준다. ([ret 숫자]의 형태로 표현) 

 

3. __fastcall

  - 매개변수가 두개 이하라면 ecx레지스터와 edx레지스터를 사용하며, 세개 이상이라면 가장 우측부터 스택에 쌓인다.

  - 호출당한 자함수측에서 스택을 정리 해준다.

  => ecx레지스터와 edx레지스터를 매개변수 호출에 사용하기 때문에 스택에 ecx와 edx를 넣어 두고, 매개변수가 정리 된 후 스택에서 pop 시켜서 ecx와 edx를 복구 시켜준다.



# 어셈블리 코드



# 소스 코드


저작자 표시 비영리 변경 금지
신고

'00. > 02. Assembly' 카테고리의 다른 글

컬링 컨베이션 세가지(cdecl, stdcall, fastcall)  (0) 2013.06.27
1 

카운터

Total : 85,369 / Today : 1 / Yesterday : 31
get rsstistory!