WIP editor

Can only read the password no safe for edit

environment/lin_editor.cpp

@@ -0,0 +1,89 @@
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <termios.h>
+#include <unistd.h>
+
+#include "environment.hpp"
+
+#ifndef STDOUT_FILENO
+#define STDOUT_FILENO 1
+#endif
+#ifndef STDIN_FILENO
+#define STDIN_FILENO 0
+#endif
+
+int getWindowSize(int *rows, int *cols)
+{
+  struct winsize ws;
+
+  // Getting window size thanks to ioctl into the given
+  // winsize struct.
+  if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == -1 || ws.ws_col == 0)
+  {
+    return -1;
+  }
+  else
+  {
+    *cols = ws.ws_col;
+    *rows = ws.ws_row;
+    return 0;
+  }
+}
+
+static struct termios orig_termios;
+
+static void disableRawMode()
+{
+  tcsetattr(STDIN_FILENO, TCSAFLUSH, &orig_termios);
+}
+
+int enableRawMode(void)
+{
+  // Save original terminal state into orig_termios.
+  if (tcgetattr(STDIN_FILENO, &orig_termios) == -1)
+    return 1;
+  // At exit, restore the original state.
+  atexit(disableRawMode);
+
+  // Modify the original state to enter in raw mode.
+  struct termios raw = orig_termios;
+  // This disables Ctrl-M, Ctrl-S and Ctrl-Q commands.
+  // (BRKINT, INPCK and ISTRIP are not estrictly mandatory,
+  // but it is recommended to turn them off in case any
+  // system needs it).
+  raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
+  // Turning off all output processing (\r\n).
+  raw.c_oflag &= ~(OPOST);
+  // Setting character size to 8 bits per byte (it should be
+  // like that on most systems, but whatever).
+  raw.c_cflag |= (CS8);
+  // Using NOT operator on ECHO | ICANON | IEXTEN | ISIG and
+  // then bitwise-AND them with flags field in order to
+  // force c_lflag 4th bit to become 0. This disables
+  // chars being printed (ECHO) and let us turn off
+  // canonical mode in order to read input byte-by-byte
+  // instead of line-by-line (ICANON), ISIG disables
+  // Ctrl-C command and IEXTEN the Ctrl-V one.
+  raw.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
+  // read() function now returns as soon as there is any
+  // input to be read.
+  raw.c_cc[VMIN] = 0;
+  // Forcing read() function to return every 1/10 of a
+  // second if there is nothing to read.
+  raw.c_cc[VTIME] = 1;
+
+  // consoleBufferOpen();
+
+  if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw) == -1)
+    return 1;
+
+  return 0;
+}
+int writeTerm(const char *buf, int length)
+{
+  return write(STDOUT_FILENO, buf, length);
+}
+int readTerm(char *buf, int length)
+{
+  return read(STDIN_FILENO, buf, length);
+}

environment/win_editor.cpp

@@ -0,0 +1,87 @@
+
+#include <stdio.h>
+#include <windows.h>
+
+#include "environment.hpp"
+
+static HANDLE hStdin = NULL;
+static HANDLE hStdout = NULL;
+static int savedConsoleOutputModeIsValid = 0;
+static DWORD savedConsoleOutputMode = 0;
+static int savedConsoleInputModeIsValid = 0;
+static DWORD savedConsoleInputMode = 0;
+
+static void disableRawMode(void)
+{
+  printf("\x1b[0m");
+  fflush(stdout);
+
+  if (savedConsoleOutputModeIsValid)
+    SetConsoleMode(hStdout, savedConsoleOutputMode);
+  if (savedConsoleInputModeIsValid)
+    SetConsoleMode(hStdin, savedConsoleInputMode);
+}
+
+int enableRawMode(void)
+{
+  // Make sure the console state will be returned to its original state
+  // when this program ends
+  atexit(disableRawMode);
+
+  // Get handles for stdin and stdout
+  hStdin = GetStdHandle(STD_INPUT_HANDLE);
+  if (hStdin == INVALID_HANDLE_VALUE || hStdin == NULL)
+    return 1;
+  hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
+  if (hStdout == INVALID_HANDLE_VALUE || hStdout == NULL)
+    return 1;
+
+  // Set console to "raw" mode
+
+  if (!GetConsoleMode(hStdout, &savedConsoleOutputMode))
+    return 1;
+  savedConsoleOutputModeIsValid = 1;
+  DWORD newOutputMode = savedConsoleOutputMode;
+  newOutputMode |= ENABLE_PROCESSED_OUTPUT;
+  newOutputMode &= ~ENABLE_WRAP_AT_EOL_OUTPUT;
+  newOutputMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+  if (!SetConsoleMode(hStdout, newOutputMode))
+    return 1;
+  if (!GetConsoleMode(hStdin, &savedConsoleInputMode))
+    return 1;
+  savedConsoleInputModeIsValid = 1;
+  DWORD newInputMode = savedConsoleInputMode;
+  newInputMode &= ~ENABLE_ECHO_INPUT;
+  newInputMode &= ~ENABLE_LINE_INPUT;
+  newInputMode &= ~ENABLE_PROCESSED_INPUT;
+  newInputMode |= ENABLE_VIRTUAL_TERMINAL_INPUT;
+  if (!SetConsoleMode(hStdin, newInputMode))
+    return 1;
+
+  return 0;
+}
+
+// https://stackoverflow.com/questions/6812224/getting-terminal-size-in-c-for-windows
+int getWindowSize(int *rows, int *cols)
+{
+  CONSOLE_SCREEN_BUFFER_INFO csbi;
+
+  GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
+  *cols = csbi.srWindow.Right - csbi.srWindow.Left + 1;
+  *rows = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
+  return 0;
+}
+
+int writeTerm(const char *buf, int length)
+{
+  unsigned long wrote = 0;
+  WriteConsoleA(hStdout, buf, length, &wrote, NULL);
+  return (int)wrote;
+}
+
+int readTerm(char *buf, int length)
+{
+  unsigned long read = 0;
+  ReadConsoleA(hStdin, buf, length, &read, NULL);
+  return (int)read;
+}

include/arg_func.hpp

@@ -20,7 +20,8 @@ enum class Arg
 	Username,		 // update username
 	Name,				 // update label name
 	File,				 // select save file
-	Size				 // show size of file
+	Size,				 // show size of file
+	Editor			 // open editor, password as note
 };
 
 Arg get_args(int argc, char **argv, char **label);
@@ -47,4 +48,6 @@ void arg_file(Buffer &decrypted_buffer, Buffer &encrypted_buffer, const char *la
 
 void arg_size(Buffer &encrypted_buffer);
 
+void arg_editor(Buffer &decrypted_buffer, Buffer &encrypted_buffer, const char *label, std::string &key);
+
 #endif

include/editor.hpp

@@ -0,0 +1,6 @@
+#ifndef EDITOR_HPP
+#define EDITOR_HPP
+
+int edit_file(const char *s);
+
+#endif // EDITOR_HPP

include/environment.hpp

@@ -8,4 +8,9 @@ bool put_data_on_clipboard(const char *text);
 std::string get_user_password();
 std::optional<std::string> get_save_path();
 
+int getWindowSize(int *rows, int *cols);
+int enableRawMode(void);
+int writeTerm(const char *buf, int length);
+int readTerm(char *buf, int length);
+
 #endif

source/arg_func.cpp

@@ -13,6 +13,7 @@
 #include "func.hpp"
 #include "buffer.hpp"
 #include "aes256.hpp"
+#include "editor.hpp"
 
 void print_args()
 {
@@ -27,6 +28,7 @@ void print_args()
 	printf(" -s <label>           show password for this label\n");
 	printf(" -u <label>           update username for this label\n");
 	printf(" -n <label>           update label name\n");
+	printf(" -e <label>           open editor, password as note\n");
 	printf(" -l                   list all labels\n");
 	printf(" -p                   print all passwords\n");
 	printf(" -c                   change master password\n");
@@ -84,6 +86,8 @@ Arg get_args(int argc, char **argv, char **label)
 		return Arg::Name;
 	case 'f':
 		return Arg::File;
+	case 'e':
+		return Arg::Editor;
 
 	default:
 		return Arg::Error;
@@ -358,4 +362,21 @@ void arg_file(Buffer &decrypted_buffer, Buffer &encrypted_buffer, const char *la
 void arg_size(Buffer &encrypted_buffer)
 {
 	printf("File size is: %zuB\n", encrypted_buffer.taken);
+}
+
+void arg_editor(Buffer &decrypted_buffer, Buffer &encrypted_buffer, const char *label_to_del, std::string &key)
+{
+	int pass = find_logininfo_in_buffer(decrypted_buffer, label_to_del);
+	if (pass < 0)
+	{
+		printf("Password not found\n");
+		return;
+	}
+
+	LoginInfoPointer lip = get_logininfo_pointer_from_buffer(decrypted_buffer, pass);
+	edit_file(lip.password);
+
+	// delete_logininfo_from_buffer(decrypted_buffer, pass);
+	// Aes256::encrypt(key, decrypted_buffer, encrypted_buffer);
+	// encrypted_buffer.save_to_file();
 }

source/editor.cpp

@@ -0,0 +1,938 @@
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <ctype.h>
+#include <stdarg.h>
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <cstring>
+
+#include "editor.hpp"
+#include "environment.hpp"
+
+/*** defines ***/
+
+#define KILO_VERSION "0.0.1"
+#define KILO_TAB_STOP 8
+#define KILO_QUIT_TIMES 3
+
+#define CTRL_KEY(k) ((k) & 0x1f)
+
+enum editorKey
+{
+  BACKSPACE = 127,
+  ARROW_LEFT = 1000,
+  ARROW_RIGHT,
+  ARROW_UP,
+  ARROW_DOWN,
+  DEL_KEY,
+  HOME_KEY,
+  END_KEY,
+  PAGE_UP,
+  PAGE_DOWN
+};
+
+/*** data ***/
+
+typedef struct erow
+{
+  int idx;
+  int size;
+  int rsize;
+  char *chars;
+  char *render;
+} erow;
+
+struct editorConfig
+{
+  int cx, cy;
+  int rx;
+  int rowoff;
+  int coloff;
+  int screenrows;
+  int screencols;
+  int numrows;
+  erow *row;
+  int dirty;
+  char *filename;
+  char statusmsg[80];
+  time_t statusmsg_time;
+  bool running;
+};
+
+struct editorConfig E;
+
+/*** prototypes ***/
+
+void editorSetStatusMessage(const char *fmt, ...);
+void editorRefreshScreen();
+char *editorPrompt(const char *prompt, void (*callback)(char *, int));
+
+/*** terminal ***/
+
+void die(const char *s)
+{
+  writeTerm("\x1b[2J", 4);
+  writeTerm("\x1b[H", 3);
+  perror(s);
+  E.running = false;
+}
+
+int editorReadKey()
+{
+  int nread;
+  char c;
+  while ((nread = readTerm(&c, 1)) != 1)
+  {
+    if (nread == -1 && errno != EAGAIN)
+      die("read");
+  }
+
+  if (c == '\x1b')
+  {
+    char seq[3];
+
+    if (readTerm(&seq[0], 1) != 1)
+      return '\x1b';
+    if (readTerm(&seq[1], 1) != 1)
+      return '\x1b';
+
+    if (seq[0] == '[')
+    {
+      if (seq[1] >= '0' && seq[1] <= '9')
+      {
+        if (readTerm(&seq[2], 1) != 1)
+          return '\x1b';
+        if (seq[2] == '~')
+        {
+          switch (seq[1])
+          {
+          case '1':
+            return HOME_KEY;
+          case '3':
+            return DEL_KEY;
+          case '4':
+            return END_KEY;
+          case '5':
+            return PAGE_UP;
+          case '6':
+            return PAGE_DOWN;
+          case '7':
+            return HOME_KEY;
+          case '8':
+            return END_KEY;
+          }
+        }
+      }
+      else
+      {
+        switch (seq[1])
+        {
+        case 'A':
+          return ARROW_UP;
+        case 'B':
+          return ARROW_DOWN;
+        case 'C':
+          return ARROW_RIGHT;
+        case 'D':
+          return ARROW_LEFT;
+        case 'H':
+          return HOME_KEY;
+        case 'F':
+          return END_KEY;
+        }
+      }
+    }
+    else if (seq[0] == 'O')
+    {
+      switch (seq[1])
+      {
+      case 'H':
+        return HOME_KEY;
+      case 'F':
+        return END_KEY;
+      }
+    }
+
+    return '\x1b';
+  }
+  else
+  {
+    return c;
+  }
+}
+
+/*** row operations ***/
+
+int editorRowCxToRx(erow *row, int cx)
+{
+  int rx = 0;
+  int j;
+  for (j = 0; j < cx; j++)
+  {
+    if (row->chars[j] == '\t')
+      rx += (KILO_TAB_STOP - 1) - (rx % KILO_TAB_STOP);
+    rx++;
+  }
+  return rx;
+}
+
+int editorRowRxToCx(erow *row, int rx)
+{
+  int cur_rx = 0;
+  int cx;
+  for (cx = 0; cx < row->size; cx++)
+  {
+    if (row->chars[cx] == '\t')
+      cur_rx += (KILO_TAB_STOP - 1) - (cur_rx % KILO_TAB_STOP);
+    cur_rx++;
+
+    if (cur_rx > rx)
+      return cx;
+  }
+  return cx;
+}
+
+void editorUpdateRow(erow *row)
+{
+  int tabs = 0;
+  int j;
+  for (j = 0; j < row->size; j++)
+    if (row->chars[j] == '\t')
+      tabs++;
+
+  free(row->render);
+  row->render = (char *)malloc(row->size + tabs * (KILO_TAB_STOP - 1) + 1);
+
+  int idx = 0;
+  for (j = 0; j < row->size; j++)
+  {
+    if (row->chars[j] == '\t')
+    {
+      row->render[idx++] = ' ';
+      while (idx % KILO_TAB_STOP != 0)
+        row->render[idx++] = ' ';
+    }
+    else
+    {
+      row->render[idx++] = row->chars[j];
+    }
+  }
+  row->render[idx] = '\0';
+  row->rsize = idx;
+}
+
+void editorInsertRow(int at, const char *s, size_t len)
+{
+  if (at < 0 || at > E.numrows)
+    return;
+
+  E.row = (erow *)realloc(E.row, sizeof(erow) * (E.numrows + 1));
+  memmove(&E.row[at + 1], &E.row[at], sizeof(erow) * (E.numrows - at));
+  for (int j = at + 1; j <= E.numrows; j++)
+    E.row[j].idx++;
+
+  E.row[at].idx = at;
+
+  E.row[at].size = len;
+  E.row[at].chars = (char *)malloc(len + 1);
+  memcpy(E.row[at].chars, s, len);
+  E.row[at].chars[len] = '\0';
+
+  E.row[at].rsize = 0;
+  E.row[at].render = NULL;
+  editorUpdateRow(&E.row[at]);
+
+  E.numrows++;
+  E.dirty++;
+}
+
+void editorFreeRow(erow *row)
+{
+  free(row->render);
+  free(row->chars);
+}
+
+void editorDelRow(int at)
+{
+  if (at < 0 || at >= E.numrows)
+    return;
+  editorFreeRow(&E.row[at]);
+  memmove(&E.row[at], &E.row[at + 1], sizeof(erow) * (E.numrows - at - 1));
+  for (int j = at; j < E.numrows - 1; j++)
+    E.row[j].idx--;
+  E.numrows--;
+  E.dirty++;
+}
+
+void editorRowInsertChar(erow *row, int at, int c)
+{
+  if (at < 0 || at > row->size)
+    at = row->size;
+  row->chars = (char *)realloc(row->chars, row->size + 2);
+  memmove(&row->chars[at + 1], &row->chars[at], row->size - at + 1);
+  row->size++;
+  row->chars[at] = c;
+  editorUpdateRow(row);
+  E.dirty++;
+}
+
+void editorRowAppendString(erow *row, char *s, size_t len)
+{
+  row->chars = (char *)realloc(row->chars, row->size + len + 1);
+  memcpy(&row->chars[row->size], s, len);
+  row->size += len;
+  row->chars[row->size] = '\0';
+  editorUpdateRow(row);
+  E.dirty++;
+}
+
+void editorRowDelChar(erow *row, int at)
+{
+  if (at < 0 || at >= row->size)
+    return;
+  memmove(&row->chars[at], &row->chars[at + 1], row->size - at);
+  row->size--;
+  editorUpdateRow(row);
+  E.dirty++;
+}
+
+/*** editor operations ***/
+
+void editorInsertChar(int c)
+{
+  if (E.cy == E.numrows)
+  {
+    editorInsertRow(E.numrows, "", 0);
+  }
+  editorRowInsertChar(&E.row[E.cy], E.cx, c);
+  E.cx++;
+}
+
+void editorInsertNewline()
+{
+  if (E.cx == 0)
+  {
+    editorInsertRow(E.cy, "", 0);
+  }
+  else
+  {
+    erow *row = &E.row[E.cy];
+    editorInsertRow(E.cy + 1, &row->chars[E.cx], row->size - E.cx);
+    row = &E.row[E.cy];
+    row->size = E.cx;
+    row->chars[row->size] = '\0';
+    editorUpdateRow(row);
+  }
+  E.cy++;
+  E.cx = 0;
+}
+
+void editorDelChar()
+{
+  if (E.cy == E.numrows)
+    return;
+  if (E.cx == 0 && E.cy == 0)
+    return;
+
+  erow *row = &E.row[E.cy];
+  if (E.cx > 0)
+  {
+    editorRowDelChar(row, E.cx - 1);
+    E.cx--;
+  }
+  else
+  {
+    E.cx = E.row[E.cy - 1].size;
+    editorRowAppendString(&E.row[E.cy - 1], row->chars, row->size);
+    editorDelRow(E.cy);
+    E.cy--;
+  }
+}
+
+/*** file i/o ***/
+
+char *editorRowsToString(int *buflen)
+{
+  int totlen = 0;
+  int j;
+  for (j = 0; j < E.numrows; j++)
+    totlen += E.row[j].size + 1; // +1 for new line
+  totlen += 1;                   // +1 for null termination
+  *buflen = totlen;
+
+  char *buf = (char *)malloc(totlen);
+  char *p = buf;
+  for (j = 0; j < E.numrows; j++)
+  {
+    memcpy(p, E.row[j].chars, E.row[j].size);
+    p += E.row[j].size;
+    *p = '\n';
+    p++;
+  }
+  *p = '\0';
+  return buf;
+}
+
+void editorOpen(const char *data)
+{
+  size_t start = 0;
+  size_t end = 0;
+
+  for (end = 0; data[end] != '\0'; end++)
+  {
+    if (data[end] == '\n')
+    {
+      editorInsertRow(E.numrows, &data[start], end - start);
+      start = end + 1;
+    }
+  }
+
+  editorInsertRow(E.numrows, &data[start], end - start);
+  E.dirty = 0;
+}
+
+void editorSave()
+{
+  if (E.filename == NULL)
+  {
+    E.filename = editorPrompt("Save as: %s (ESC to cancel)", NULL);
+    if (E.filename == NULL)
+    {
+      editorSetStatusMessage("Save aborted");
+      return;
+    }
+  }
+
+  int len;
+  char *buf = editorRowsToString(&len);
+
+  std::ofstream file(E.filename, std::ios::binary | std::ios::out);
+  if (!file.is_open())
+  {
+    free(buf);
+    editorSetStatusMessage("Can't save! I/O error");
+    return;
+  }
+  file.write(buf, len);
+  file.close();
+
+  free(buf);
+  editorSetStatusMessage("Saved to disk");
+  E.dirty = 0;
+}
+
+/*** find ***/
+
+void editorFindCallback(char *query, int key)
+{
+  static int last_match = -1;
+  static int direction = 1;
+
+  if (key == '\r' || key == '\x1b')
+  {
+    last_match = -1;
+    direction = 1;
+    return;
+  }
+  else if (key == ARROW_RIGHT || key == ARROW_DOWN)
+  {
+    direction = 1;
+  }
+  else if (key == ARROW_LEFT || key == ARROW_UP)
+  {
+    direction = -1;
+  }
+  else
+  {
+    last_match = -1;
+    direction = 1;
+  }
+
+  if (last_match == -1)
+    direction = 1;
+  int current = last_match;
+  int i;
+  for (i = 0; i < E.numrows; i++)
+  {
+    current += direction;
+    if (current == -1)
+      current = E.numrows - 1;
+    else if (current == E.numrows)
+      current = 0;
+
+    erow *row = &E.row[current];
+    char *match = strstr(row->render, query);
+    if (match)
+    {
+      last_match = current;
+      E.cy = current;
+      E.cx = editorRowRxToCx(row, match - row->render);
+      E.rowoff = E.numrows;
+      break;
+    }
+  }
+}
+
+void editorFind()
+{
+  int saved_cx = E.cx;
+  int saved_cy = E.cy;
+  int saved_coloff = E.coloff;
+  int saved_rowoff = E.rowoff;
+
+  char *query = editorPrompt("Search: %s (Use ESC/Arrows/Enter)", editorFindCallback);
+
+  if (query)
+  {
+    free(query);
+  }
+  else
+  {
+    E.cx = saved_cx;
+    E.cy = saved_cy;
+    E.coloff = saved_coloff;
+    E.rowoff = saved_rowoff;
+  }
+}
+
+/*** append buffer ***/
+
+struct abuf
+{
+  char *b;
+  int len;
+  int size;
+};
+
+#define ABUF_INIT {NULL, 0, 0}
+
+void abAppend(struct abuf *ab, const char *s, int len)
+{
+  if (ab->len + len > ab->size)
+  {
+    ab->size = (ab->len + len) * 2;
+    ab->b = (char *)realloc(ab->b, ab->size);
+  }
+  memcpy(&ab->b[ab->len], s, len);
+  ab->len += len;
+}
+
+void abFree(struct abuf *ab)
+{
+  free(ab->b);
+}
+
+/*** output ***/
+
+void editorScroll()
+{
+  E.rx = 0;
+  if (E.cy < E.numrows)
+  {
+    E.rx = editorRowCxToRx(&E.row[E.cy], E.cx);
+  }
+
+  if (E.cy < E.rowoff)
+  {
+    E.rowoff = E.cy;
+  }
+  if (E.cy >= E.rowoff + E.screenrows)
+  {
+    E.rowoff = E.cy - E.screenrows + 1;
+  }
+  if (E.rx < E.coloff)
+  {
+    E.coloff = E.rx;
+  }
+  if (E.rx >= E.coloff + E.screencols)
+  {
+    E.coloff = E.rx - E.screencols + 1;
+  }
+}
+
+void editorDrawRows(struct abuf *ab)
+{
+  int y;
+  for (y = 0; y < E.screenrows; y++)
+  {
+    int filerow = y + E.rowoff;
+    if (filerow >= E.numrows)
+    {
+      if (E.numrows == 0 && y == E.screenrows / 3)
+      {
+        char welcome[80];
+        int welcomelen = snprintf(welcome, sizeof(welcome),
+                                  "Kilo editor -- version %s", KILO_VERSION);
+        if (welcomelen > E.screencols)
+          welcomelen = E.screencols;
+        int padding = (E.screencols - welcomelen) / 2;
+        if (padding)
+        {
+          abAppend(ab, "~", 1);
+          padding--;
+        }
+        while (padding--)
+          abAppend(ab, " ", 1);
+        abAppend(ab, welcome, welcomelen);
+      }
+      else
+      {
+        abAppend(ab, "~", 1);
+      }
+    }
+    else
+    {
+      int len = E.row[filerow].rsize - E.coloff;
+      if (len < 0)
+        len = 0;
+      if (len > E.screencols)
+        len = E.screencols;
+      char *c = &E.row[filerow].render[E.coloff];
+      int current_color = -1;
+      int j;
+      for (j = 0; j < len; j++)
+      {
+        if (iscntrl(c[j]))
+        {
+          char sym = (c[j] <= 26) ? '@' + c[j] : '?';
+          abAppend(ab, "\x1b[7m", 4);
+          abAppend(ab, &sym, 1);
+          abAppend(ab, "\x1b[m", 3);
+          if (current_color != -1)
+          {
+            char buf[16];
+            int clen = snprintf(buf, sizeof(buf), "\x1b[%dm", current_color);
+            abAppend(ab, buf, clen);
+          }
+        }
+        else
+        {
+          if (current_color != -1)
+          {
+            abAppend(ab, "\x1b[39m", 5);
+            current_color = -1;
+          }
+          abAppend(ab, &c[j], 1);
+        }
+      }
+      abAppend(ab, "\x1b[39m", 5);
+    }
+
+    abAppend(ab, "\x1b[K", 3);
+    abAppend(ab, "\r\n", 2);
+  }
+}
+
+void editorDrawStatusBar(struct abuf *ab)
+{
+  abAppend(ab, "\x1b[7m", 4);
+  char status[80], rstatus[80];
+  int len = snprintf(status, sizeof(status), "%.20s - %d lines %s",
+                     E.filename ? E.filename : "[No Name]", E.numrows,
+                     E.dirty ? "(modified)" : "");
+  int rlen = snprintf(rstatus, sizeof(rstatus), "%s | %d/%d",
+                      "no ft", E.cy + 1, E.numrows);
+  if (len > E.screencols)
+    len = E.screencols;
+  abAppend(ab, status, len);
+  while (len < E.screencols)
+  {
+    if (E.screencols - len == rlen)
+    {
+      abAppend(ab, rstatus, rlen);
+      break;
+    }
+    else
+    {
+      abAppend(ab, " ", 1);
+      len++;
+    }
+  }
+  abAppend(ab, "\x1b[m", 3);
+  abAppend(ab, "\r\n", 2);
+}
+
+void editorDrawMessageBar(struct abuf *ab)
+{
+  abAppend(ab, "\x1b[K", 3);
+  int msglen = strlen(E.statusmsg);
+  if (msglen > E.screencols)
+    msglen = E.screencols;
+  if (msglen && time(NULL) - E.statusmsg_time < 5)
+    abAppend(ab, E.statusmsg, msglen);
+}
+
+void editorRefreshScreen()
+{
+  editorScroll();
+
+  struct abuf ab = ABUF_INIT;
+
+  abAppend(&ab, "\x1b[?25l", 6);
+  abAppend(&ab, "\x1b[H", 3);
+
+  editorDrawRows(&ab);
+  editorDrawStatusBar(&ab);
+  editorDrawMessageBar(&ab);
+
+  char buf[32];
+  snprintf(buf, sizeof(buf), "\x1b[%d;%dH", (E.cy - E.rowoff) + 1,
+           (E.rx - E.coloff) + 1);
+  abAppend(&ab, buf, strlen(buf));
+
+  abAppend(&ab, "\x1b[?25h", 6);
+
+  writeTerm(ab.b, ab.len);
+  abFree(&ab);
+}
+
+void editorSetStatusMessage(const char *fmt, ...)
+{
+  va_list ap;
+  va_start(ap, fmt);
+  vsnprintf(E.statusmsg, sizeof(E.statusmsg), fmt, ap);
+  va_end(ap);
+  E.statusmsg_time = time(NULL);
+}
+
+/*** input ***/
+
+char *editorPrompt(const char *prompt, void (*callback)(char *, int))
+{
+  size_t bufsize = 128;
+  char *buf = (char *)malloc(bufsize);
+
+  size_t buflen = 0;
+  buf[0] = '\0';
+
+  while (E.running)
+  {
+    editorSetStatusMessage(prompt, buf);
+    editorRefreshScreen();
+
+    int c = editorReadKey();
+    if (c == DEL_KEY || c == CTRL_KEY('h') || c == BACKSPACE)
+    {
+      if (buflen != 0)
+        buf[--buflen] = '\0';
+    }
+    else if (c == '\x1b')
+    {
+      editorSetStatusMessage("");
+      if (callback)
+        callback(buf, c);
+      free(buf);
+      return NULL;
+    }
+    else if (c == '\r')
+    {
+      if (buflen != 0)
+      {
+        editorSetStatusMessage("");
+        if (callback)
+          callback(buf, c);
+        return buf;
+      }
+    }
+    else if (!iscntrl(c) && c < 128)
+    {
+      if (buflen == bufsize - 1)
+      {
+        bufsize *= 2;
+        buf = (char *)realloc(buf, bufsize);
+      }
+      buf[buflen++] = c;
+      buf[buflen] = '\0';
+    }
+
+    if (callback)
+      callback(buf, c);
+  }
+  return NULL;
+}
+
+void editorMoveCursor(int key)
+{
+  erow *row = (E.cy >= E.numrows) ? NULL : &E.row[E.cy];
+
+  switch (key)
+  {
+  case ARROW_LEFT:
+    if (E.cx != 0)
+    {
+      E.cx--;
+    }
+    else if (E.cy > 0)
+    {
+      E.cy--;
+      E.cx = E.row[E.cy].size;
+    }
+    break;
+  case ARROW_RIGHT:
+    if (row && E.cx < row->size)
+    {
+      E.cx++;
+    }
+    else if (row && E.cx == row->size)
+    {
+      E.cy++;
+      E.cx = 0;
+    }
+    break;
+  case ARROW_UP:
+    if (E.cy != 0)
+    {
+      E.cy--;
+    }
+    break;
+  case ARROW_DOWN:
+    if (E.cy < E.numrows)
+    {
+      E.cy++;
+    }
+    break;
+  }
+
+  row = (E.cy >= E.numrows) ? NULL : &E.row[E.cy];
+  int rowlen = row ? row->size : 0;
+  if (E.cx > rowlen)
+  {
+    E.cx = rowlen;
+  }
+}
+
+void editorProcessKeypress()
+{
+  static int quit_times = KILO_QUIT_TIMES;
+
+  int c = editorReadKey();
+
+  switch (c)
+  {
+  case '\r':
+    editorInsertNewline();
+    break;
+
+  case CTRL_KEY('q'):
+    if (E.dirty && quit_times > 0)
+    {
+      editorSetStatusMessage("WARNING!!! File has unsaved changes. "
+                             "Press Ctrl-Q %d more times to quit.",
+                             quit_times);
+      quit_times--;
+      return;
+    }
+    writeTerm("\x1b[2J", 4);
+    writeTerm("\x1b[H", 3);
+    E.running = false;
+    break;
+
+  case CTRL_KEY('s'):
+    editorSave();
+    break;
+
+  case HOME_KEY:
+    E.cx = 0;
+    break;
+
+  case END_KEY:
+    if (E.cy < E.numrows)
+      E.cx = E.row[E.cy].size;
+    break;
+
+  case CTRL_KEY('f'):
+    editorFind();
+    break;
+
+  case BACKSPACE:
+  case CTRL_KEY('h'):
+  case DEL_KEY:
+    if (c == DEL_KEY)
+      editorMoveCursor(ARROW_RIGHT);
+    editorDelChar();
+    break;
+
+  case PAGE_UP:
+  case PAGE_DOWN:
+  {
+    if (c == PAGE_UP)
+    {
+      E.cy = E.rowoff;
+    }
+    else if (c == PAGE_DOWN)
+    {
+      E.cy = E.rowoff + E.screenrows - 1;
+      if (E.cy > E.numrows)
+        E.cy = E.numrows;
+    }
+
+    int times = E.screenrows;
+    while (times--)
+      editorMoveCursor(c == PAGE_UP ? ARROW_UP : ARROW_DOWN);
+  }
+  break;
+
+  case ARROW_UP:
+  case ARROW_DOWN:
+  case ARROW_LEFT:
+  case ARROW_RIGHT:
+    editorMoveCursor(c);
+    break;
+
+  case CTRL_KEY('l'):
+  case '\x1b':
+    break;
+
+  default:
+    editorInsertChar(c);
+    break;
+  }
+
+  quit_times = KILO_QUIT_TIMES;
+}
+
+/*** init ***/
+
+void initEditor()
+{
+  E.cx = 0;
+  E.cy = 0;
+  E.rx = 0;
+  E.rowoff = 0;
+  E.coloff = 0;
+  E.numrows = 0;
+  E.row = NULL;
+  E.dirty = 0;
+  E.filename = NULL;
+  E.statusmsg[0] = '\0';
+  E.statusmsg_time = 0;
+  E.running = true;
+
+  if (getWindowSize(&E.screenrows, &E.screencols) == -1)
+    die("getWindowSize");
+  E.screenrows -= 2;
+}
+
+int edit_file(const char *s)
+{
+  initEditor();
+  if (s)
+  {
+    editorOpen(s);
+  }
+
+  enableRawMode();
+  editorSetStatusMessage("HELP: Ctrl-S = save | Ctrl-Q = quit | Ctrl-F = find");
+
+  while (E.running)
+  {
+    editorRefreshScreen();
+    editorProcessKeypress();
+  }
+
+  return 0;
+}

source/environment.cpp

@@ -7,6 +7,8 @@
 
 #ifdef _WIN32
 #include "../environment/win.cpp"
+#include "../environment/win_editor.cpp"
 #else
 #include "../environment/lin.cpp"
+#include "../environment/lin_editor.cpp"
 #endif

source/main.cpp

@@ -141,6 +141,10 @@ int main(int argc, char **argv)
 		arg_size(encrypted_buffer);
 		break;
 
+	case Arg::Editor:
+		arg_editor(decrypted_buffer, encrypted_buffer, label, user_pass);
+		break;
+
 	case Arg::Error:
 		break;
 	}