Lembrete para conversão de base no Python, a primera coluna é o valor de entrada e a primeira linha o valor de saída.

Pode-se converter para outras bases entre 2 e 36 utilizando int(<numero>,<base>), exemplo:

>>> print int('g',18)
16

Posted in programação Tagged: python ]]> http://escovandobits.wordpress.com/2009/07/05/conversao-de-base-no-python/feed/ 0 Tiago Maluta http://escovandobits.wordpress.com/2009/05/23/vmware-esx/ http://escovandobits.wordpress.com/2009/05/23/vmware-esx/#comments Sat, 23 May 2009 04:48:43 +0000 Tiago Maluta http://escovandobits.wordpress.com/?p=483 ]]>

Ainda não testei num hardware apropriado… mas hoje quando fiz um teste rápido com com o VMware ESXi no QEmu percebi que ele detectou “aonde” estava rodando.

Para ver mais screenshots clique aqui.

As CPUs modernas possuem alguns registros especiais dentre os quais há o grupo de instruções: Memory Type Range Registers (MTRRs) que provém um sistema de como o acesso a faixas de memória são transferidas para a cache. Nesse caso a mensagem [No variable MTRRS] indica como o VMware detectou.  [assim que sobrar um tempo irei buscar a fundo o motivo real da virtualização não implementar isso]

Utilizei o seguinte comando para rodar o Qemu:

./qemu -cpu coreduo -m 1500 \
 -hda vm.cow \
 -cdrom VMware-VMvisor-InstallerCD-3.5.0_Update_4-153875.i386.iso

A título de exemplo,  vejam um programa para detectar se o seu programa está em uma máquina virtual (no caso VMware):

#include <stdlib.h>
#include <unistd.h>
#include <signal.h>

#define MAGIC 0x564d5868 /* "VMXh" */
#define PORT 0x5658       /* "VX" */
#define GETVERSION 0x0a

static char *versions[] =
  {"??","Express","ESX Server","GSX Server","Workstation" };

static int vlen[] = {2,7,10,10,11};

static void segfault(){
    write(1,"Not a VMware box.\n",18);
    exit(1);
}

int main(){
    unsigned int ok, ver, magic;

    signal(11, segfault);
    __asm__ __volatile__ (" \
         push %%ebx          \n\
         in %%dx, %%eax      \n\
         mov %%ebx, %1       \n\
         pop %%ebx           \n\
       "
       : "=a"(ok), "=m"(magic), "=c"(ver)
       : "0" (MAGIC), "c" (GETVERSION), "d" (PORT)
    );

    if (magic == MAGIC) {
       write(1, "VMware ", 7);
       if (ok == 6) {
               write(1, versions[ver], vlen[ver]);
               write(1, "\n", 1);
       }
       else write(1, "unknown\n",8);
    }
    else write(1, "Not vmware\n",11);
    exit(0);
}

Isso foi só um motivacional. Isso é assunto para outros posts, ainda estou aprendendo as metodologias utilizadas em virtualização,  esperem em breve posts com temas interessantíssimos.

Esse post irá mostrar uma pequena dica para quem deseja começar a testar programas de terceiros de uma forma organizada, de modo a preservar os “originais” do sistema e permitir isolar as versões.

Na maioria dos casos quando testamos um programa pelo código-fonte, utilizamos a forma definida no autoconf, muito tradicional no sistema GNU, onde:  descompactamos, verificamos o sistema (configure),  compilamos (make) e copiamos para a pasta correspondente na hieraquia de pastas do sistema (make install).

 tar zxvf programa.tar.gz
 cd programa
 ./configure
 make
 make install

Contudo, se estamos trabalhando com versões de desenvolvimento não queremos copiar os binários gerados para o sistema.  Pode ser que eu tenha uma versão X do software funcionando e a verão Y que desejo testar quebre a compatibildade com algum outro programa do sistema.  Vamos considerar o seguinte exemplo: suponha que você viu no site do projeto binutils que há um novo linker (A new, faster, ELF only linker, still in beta test.) e deseje compilar esta nova versão para testá-la. Utilizando o processo descrito acima você irá sobreescrever a versão distribuida pelos desenvolvedores da sua distribuição e não queremos que isso ocorra, principalmente quando o software está na versão beta do seu desenvolvimento. Vamos pensar outra maneira:

 wget http://ftp.gnu.org/gnu/binutils/binutils-2.9.tar.gz
 tar zxvf binutils-2.9.tar.gz
 cd binutils-2.9

Se olharmos as opções de ajuda (–help) do script configure vemos que podemos setar o prefixo da instalação:

 --prefix=MYDIR          install into MYDIR [/usr/local]

Então basta escolher o diretório para colocar os executáveis.

 ./configure --prefix=../install

Mas ainda há uma maneira, ao meu ver, mais organizada, principalmente se você está desenvolvendo um software. Depois de descompactar o programa, crie dois diretórios: um chamado build que irá conter os arquivos gerados pelo compilador e um install que terá apenas os executáveis.

 cd ..
 mkdir build install

No final teremos os diretórios:

 .
 |-- binutils-2.9
 |-- build
 `-- install

Uma pasta com o código-fonte, outra com os arquivos objeto (resultado da etapa de compilação) e o executáveis.

 cd build
 ../binutils-2.9/configure --prefix=$(cd ../install && pwd)

Depois disso siga normalmente o processo de make e make install lembrando que os executáveis agora ficarão na pasta install/.  Essa metodologia é simples e muito útil,  principalmente quando estamos trabalhando com algum programa de controle de versão (ex.: git) e desenvolvendo testes em arquiteturas diferentes.

Caso especial: kernel

O Linux não possui um script de configuração (configure) portanto é preciso especificar no ‘make’ no local. Para manter a mesma árvore compilando para diferentes arquiteturas.

alias make-cross= \
"make O=../buildsh ARCH=sh CROSS_COMPILE=sh4-unknown-linux-gnu-"
make-cross menuconfig
make-cross

Como descrito no post anterior, o suporte do Qemu ao hardware do N800 permite emulá-lo. Vamos dar uma olhada nisso…

Como é necessário fazer algumas modificações no código do Qemu para rodar a última versão (Diablo) vamos fazer o download do Qemu no repositório do projeto (o mantenedores do projeto migraram para o “git” nesse mês)

1. Instalando o QEmu

# cd ~/qemu-n800
# git clone git://git.savannah.nongnu.org/qemu.git

Para rodar a última versão do Maemo (Diablo) é necessário alterar a tabela de partições:

# cd qemu
# git checkout -b n800-diablo
# wget http://tinyurl.com/cuyx4s
# git apply 0001-Resized-N800-partition-table.patch

# cd ~/qemu-n800
# mkdir build install
# cd build
# ../qemu/configure \
--target-list="arm-softmmu arm-linux-user armeb-linux-user" \
--prefix=$(cd ../install && pwd)
# make
# make install

# ../install/bin/qemu-system-arm -h | head -n 1
QEMU PC emulator version 0.10.50, \
Copyright (c) 2003-2008 Fabrice Bellard

2. Download Nokia N800 Maemo Firmware

• Vá até o endereço http://maemo.org/community/wiki/HOWTO_FlashLatestNokiaImageWithLinux/
• Faça o download selecionado a versão apropriada (Software Edition 2008 version 5.2008.43-7 for Nokia N800)
  Observação: Isso é um ponto que me incomodou, infelizmente você irá precisar de um serial number do N800 — se você não tem um Nokia N800 agora é o momendo para adquirir um… Como não investiguei as considerações legais a respeito (nem se é uma violação a GPL). E como não vi ninguém na internet disponibilizando, por enquanto não vou disponibilizar a minha. 
  
• Firmware em http://tablets-dev.nokia.com/nokia_N800.php (N800)
  • mkdir ~/qemu-n800/os2008/
  • Irei considerar o nome  RX-34_DIABLO_5.2008.43-7_PR_COMBINED_MR0_ARM.bin
• Faça o download do Nokia Nseries Firmware Flashing Tool version 3
  • Link em http://tablets-dev.nokia.com/d3.php
  • Salve em ~/qemu-n800
  • Esse ponto é importante, você irá precisar reinstalar (faça o backup dos seus dados!) o sistema no seu N800 para pegar alguns dados de configuração de uma partição do N800, o comando que utilizei para gravar a flash está descrito no item 3)

3. Atualizando o firmware no dispositivo

• Certifique-se que a bateria esteja carregada e deslige o N800.
• Conecte o cabo USB (não ligue o aparelho)
• Execute o comando abaixo,  para emular o N800 é preciso setar uma flag que os desenvolvedores utilizam quando estão desenvolvendo. (Leia o item [3] no final para maiores informações)

# mkdir ~/qemu-n800/os2008/diablo/
# cd ~/qemu-n800/os2008/diablo/
# ../../flasher-3.0 --set-rd-flags=no-lifeguard-reset \
-u -R -f -F ../RX-34_DIABLO_5.2008.43-7_PR_COMBINED_MR0_ARM.bin

SW version in image: RX-34_DIABLO_5.2008.43-7_PR_MR0

(...)

Unpacking kernel image to file \'zImage\'...
Unpacking initfs image to file \'initfs.jffs2\'...
Unpacking rootfs image to file \'rootfs.jffs2\'...

(...)

Suitable USB device not found, waiting

• Pressione o botão Power e Home e mantenha-os até o fim do processo. Lembre-se que seu usuário irá precisar de ter permissão para escrever na USB ou então utilize o “root”.

USB device found found at bus 002, device address 007
Found device RX-34, hardware revision 1302
NOLO version 1.1.16
Version of \'sw-release\': RX-34_DIABLO_5.2008.43-7_PR_MR0
Sending xloader image (8 kB)...100% (8 of 8 kB, avg. 2218 kB/s)
Sending secondary image (96 kB)...
100% (96 of 96 kB, avg. 12093 kB/s)
Flashing bootloader... done.
Sending kernel image (1500 kB)...
100% (1500 of 1500 kB, avg. 17449 kB/s)
Flashing kernel... done.
Sending initfs image (2273 kB)...
100% (2273 of 2273 kB, avg. 19264 kB/s)
Flashing initfs... done.
Sending and flashing rootfs image (134912 kB)...
100% (134912 of 134912 kB, avg. 7369 kB/s)
Finishing flashing... done
Set R&D flags: 0008

No meu caso ele não reiniciou automaticamente, precisei desconectar o cabo usb e desligá-lo/ligá-lo para funcionar.

4. Preparando os arquivos

Note que além do dispositivo gravado seu diretório conterá alguns arquivos  (~/qemu-n800/os2008/diablo):

2nd.bin-RX-34:1301,1302,1501,1502,1503,1504,1601,1602
secondary.bin-RX-34:1301,1302,1501,1502,1503,1504,1601,1602
xloader.bin-RX-34:1301,1302,1501,1502,1503,1504,1601,1602
initfs.jffs2
rootfs.jffs2
zImage

• Intale o  “Poky Linux” Project’s Flash Filesystem Tool
  • # cd ~/qemu-n800
  • # svn cat http://svn.o-hand.com/repos/poky/trunk/scripts/poky-nokia800-flashutil > poky-nokia800-flashutil
  • chmod +x poky-nokia800-flashutil
  • Edite o arquivo poky-nokia800-flashutil e descomente a linha referente ao rootfs_offset
    

# This value should be selected for Diablo based firmwares
# It also require patching qemu to get proper size of flash partitions
# (by default qemu has Chinook split).
rootfs_offset=3328 # diablo

• Extraia a partição de configuração do seu Nokia N800
  • Você irá precisar instalar algum servidor SSH, disponível pelo Gerenciador de aplicativos, com o catálogo maemo Extras ativado .
  • mkdir ~/qemu-n800/qemu-img
  • ssh root@<N800 IP> cat /dev/mtd1ro > config.mtd
    • recomendo instalar também o aplicativo HomeIP para verificar seu endereço.

• Utilizaremos o “Poky Linux” Project’s Flash Filesystem Tool para criar um sistema de arquivos para o sistema emulado:

# cd ~/qemu-n800/qemu-img
#../poky-nokia800-flashutil ../os2008/diablo/initfs.jffs2 \
qemu-n800.img initfs
#../poky-nokia800-flashutil config.mtd qemu-n800.img config
#../poky-nokia800-flashutil ../os2008/diablo/rootfs.jffs2 \
qemu-n800.img rootfs

• Inicie o Qemu com as seguintes opções:

# cd ~/qemu-n800/qemu-img
# ~/qemu-n800/qemu/install/bin/qemu-system-arm \
-kernel ../os2008/zImage -M n800 \
-mtdblock qemu-n800.img \
-m 130 \
-append "root=/dev/mtdblock3 rootfstype=jffs2"

Para fazer o teclado funcionar adicione no final do comando: -usb -usbdevice keyboard

Bootstrap do N800 no QEmu

Imagem padrão da Nokia

N800 no QEmu

5. Considerações e Futuro

• A emulação mostrou-se um pouco lenta. Na primeira vez que bootou senti meio devagar, mas nos outros boots achei até que razozável a velocidade.
• Preciso arrumar uma forma de colocar um “‘ponteiro” para a caneta stylus, pois embora o mouse funcione ele não mostra a posição  na tela.
• A alteração no código do Qemu foi específica para a ultima versão do OS 2008 (Diablo), acredito que o Qemu irá incorporar um maneira para permitir multiplas versões do Maemo sem precisar alterar o código.
• Configurar a rede.

6. Recomendo ler o que já foi publicado a respeito

[1] http://www.rkeene.org/projects/info/wiki/106

[2] http://marcin.juszkiewicz.com.pl/2008/04/11/nokia-n800-emulation/

[3] http://marcin.juszkiewicz.com.pl/2008/08/01/nokia-n8×0-emulation-part-ii/

Resolvi comprar numa promoção do Submarino.com.br um N800 para dar de presente a minha mãe no dia das mães. Enquanto o dia “oficialmente” não chega, vou publicar algumas coisas que andei brincando.

Tela do OS 2008

O N800 roda uma versão adaptada do GNU/Linux chamada Maemo (OS 2007). A primeira coisa que fiz depois de dar uma fuçada inicial foi atualizar o firmware para a versão OS 2008.  No meu notebook rodando Gentoo esse processo foi praticamente direto seguindo os passos do wiki do Maemo:

./flasher-3.0 -F RX-34_DIABLO_5.2008.43-7_PR_COMBINED_MR0_ARM.bin -f -R

flasher v0.8.7 (Oct 17 2006)

SW version in image: RX-34_DIABLO_5.2008.43-7_PR_MR0

(...)

Flashing bootloader... done.
Sending kernel image (1500 kB)...
100% (1500 of 1500 kB, avg. 10874 kB/s)
Flashing kernel... done.
Sending initfs image (2273 kB)...
100% (2273 of 2273 kB, avg. 22286 kB/s)
Flashing initfs... done.
Sending and flashing rootfs image (134912 kB)...
100% (134912 of 134912 kB, avg. 7367 kB/s)
Finishing flashing... done

Com a versão nova percebe-se imediatamente as melhorias comparadas a versão antiga. A interface gráfica está muito mais amigável e o suporte está mais refinado.

Browser

O browser utiliza uma engine do Mozilla, consegui abrir sites que rodam flash bem como acessar sites de bancos. É difícil enquadrar o N800 em um grupo específico, pois ele não é um smartphone. Contudo, se compararmos com outros dispositivos atuais e similares (pelo menos em alguma funcionalidade) como o iPhone (Mac OSX) ou o HTC G1 (Android) percebe-se que ele é um dispositivo mais aberto aos entusiastas que desejam “fuçar”.  O site Ars Technica fez uma breve comparação com o iPod Touch. O usuário de alguma distribuição GNU/Linux baseada no GNOME vai sentir-se familiarizado com os aplicativos disponíveis: pidgin, gnumeric, evince, x-chat, etc; todos previamente hildonizados (adequados ao tamanho e  integrado a para melhor usabilidade da tela). Fiquei impressionado com o suporte a outros aplicativos básicos como mplayer, skype, gizmo e codecs como ogg. Tecnicamente qualquer aplicativo que rode na sua distribuição pode ser portável para o N800.

Também achei fácil a maneira de instalar a remover programas através do Gerenciador de aplicativos,  lá você pode selecionar numa lista, fazer o download e instalar/remover programas.

Um programa que achei interessante é o media center Canola2 que foi desenvolvido em Python com as bibliotecas gráficas do Enlightment.

Após instalar alguns aplicativos como o ssh (openssh server/client) e testar o emulador de terminal (osso_xterm) chegou a hora de pegar algumas informações do sistema. Comecei pelas informações da CPU em /proc/cpuinfo.

Primeiro com o emulador do terminal:

Agora vejam a saída pelo SSH:

Reparem na diferença do valor dos BogoMIPS no ssh (164.36) e no X Terminal (397.46). Não pensei ainda o porquê dessa diferença, mas vou procurar.

Peguei outras informações que bateram nas duas análises, como a memória flash está particionada:

dev:    size   erasesize  name
mtd0: 00020000 00020000 “bootloader” (128KB)
mtd1: 00060000 00020000 “config” (384KB)
mtd2: 00200000 00020000 “kernel” (2MB)
mtd3: 00400000 00020000 “initfs” (4MB)
mtd4: 0f980000 00020000 “rootfs” (249.5MB)

Fiz o dump mas ainda não analisei efetivamente há alguma informação útil. O sistema executa o kernel 2.6.21 (cmdline: root=1f03 rootfstype=jffs2 ro console=tty0 console=ttyMTD5) e o máximo que consegui de informações iniciais do dmesg foi a partir do instante 0.687500 (segundos), ou seja, não consegui aquelas informações realmente do começo (a partir do instante zero). Contudo dá para ter idéia de algumas coisas, como por exemplo, que os desenvolvedores utilizam o Qemu para fazer os testes enquanto desenvolvem.

[    0.687500]
/home/bifh4/diablo-uarm-prereleased.gcc34qemu/work/\
kernel-diablo-2.6.21/kernel-source-diablo/drivers/\
usb/input/hid-core.c: v2.6:USB HID core driver                                                                                                                                                       
[    0.687500]
/home/bifh4/diablo-uarm-prereleased.gcc34qemu/work/\
kernel-diablo-2.6.21/kernel-source-diablo/drivers/\
usb/net/rtl8150.c: rtl8150 based usb-ethernet driver v0.6.2                                                                                                                      

Isso é fato pois o a última versão estável do Qemu (0.10.0) suporta a emulação do hardware do N8×0. Reparem que é a mesma plataforma tanto no N800 como no N810.

#qemu-system-arm -M ? | grep Nokia

n800       Nokia N800 tablet aka. RX-34 (OMAP2420)
n810       Nokia N810 tablet aka. RX-44 (OMAP2420)

Há sites ensinando como se faz isso e espero escrever alguma coisa a respeito no futuro haja visto que o N800 é um presente

Essa foi uma análise breve, de um dia, no N800. Talvez um ponto crítico seja não ter o suporte a redes GSM (GPRS) mas isso hoje pode ser contornado utilizando um celular e fazendo a ponte via bluetooth. Além disso a plataforma OMAP da TI é poderosa o suficiente para  utilizar e desenvolver aplicativos que precisem de desempenho (dentro de certo limites é claro) e o preço das promoções no Brasil está fazendo valer a pena.

N800 + Teclado bluetooth

O Motorola 6800 não possui uma instrução específica para divisão de dois números. Uma solução simples é fazer a divisão através de múltiplas subtrações. Contudo, podemos pensar mecanismos mais eficientes. Uma solução  esta descrita no código-abaixo. Esse algoritmo é mais eficiente na maiora dos casos, pois com apenas 8 deslocamentos efetua a divisão de dois números de 8 bits.

O primeiro caso é quando temos números absolutos.

                LDAA Divisor       
                BEQ __end        ; caso Divisor = 0

                ; o contador ira deslocar 8 vezes,
                ; mas como já começo decrementando
                ; carrego com 9.

                LDAA #$09      
                STAA Contador
                CLRA
                BRA loop_div

empurra_zero:   ASL Resposta  

loop_div:       DEC Contador  ; decrementa contador
                BEQ __end

                ASL Dividendo ; desloca o dividendo p/ Carry
                ROLA          ; desloga do Carry p/ ACCA
                CMPA Divisor  ; Acumulador - Dividor > 0

                BCS empurra_zero

                SEC           ; set carry 
                ROL Resposta  ; empurra '1' na resposta
                SUBA Divisor
                BRA loop_div

__end:          NOP

Se os números forem sinalizados precisamos considerar isso na conta, portanto antes de dividir o número devemos verificar seu sinal. O código abaixo utiliza duas posições de memória para o sinal do número.  No final é feito uma OU-Exclusivo para definir qual sinal da resposta.

            CLR Neg_Divisor
            CLR Neg_Dividendo               
            LDAA Divisor
            BEQ __end        ; caso Divisor = 0
            BPL skip

            NEG Divisor
            DEC Neg_Divisor  ; Neg_Divisor = 1 (0xff)

skip:       LDAA Dividendo
            BPL __div        ; Neg_Dividendo = 1 (0xff)

            NEG Dividendo
            DEC Neg_Dividendo

            ; o contador ira deslocar 8 vezes, mas
            ; como já começo decrementando
            ; carrego com 9.

__div:          LDAA #$09      
                STAA Contador
                CLRA
                BRA loop_div

empurra_zero:   ASL Resposta  

loop_div:       DEC Contador   ; decrementa contador
                BEQ __end

                ASLA Dividendo ; desloca o dividendo p/ Carry
                ROLA           ; desloga do Carry p/ ACCA
                CMPA Divisor   ; Acumulador - Dividor > 0

                BCS empurra_zero

                SEC           ; set carry 
                ROL Resposta  ; empurra '1' na resposta
                SUB Divisor
                BRA loop_div

__end:          LDAA Neg_Divisor
                EORA Neg_Dividendo 
                ; a lógica da XOR garante o estudo dos sinais
                BPL _end 

                NEG Resposta          
_end:           NOP    

Quem programa em Python provavelmente já precisou fazer alguma coisa com threads. Contudo quando estamos trabalhando com PyQT há alguns incovenientes em utilizar as threads da API do Python, principalmente quando temos interfaces gráficas. Recentemente tive problemas para fazer uma função que executasse determinada ação após um tempo pré-definido em segundos. Pois quando enquanto a thread não terminasse sua execução a janela gráfica não aparecia.  Encontrei duas maneiras para solucionar,  a primeira utilizando QThread e uma muito mais simples usando QTimer,  fica o registro das duas maneiras:

from PyQt4 import *
from PyQt4.QtCore import *

class MyTimer(QThread):
	def __init__(self,parent = None):
		QThread.__init__(self,parent)

	def run(self):
		while 1:
		# a cada 'self.tempo' segundos o sinal é emitido e
                  nós tratamos na outra classe. Exemplo:
			self.emit(SIGNAL("sinal_atualiza()"))
			self.sleep(self.tempo)

	def Timer(self,t=5):
		self.tempo = t
		self.start()

Depois, na sua classe basta que gerencia a interface gráfica, basta instanciar o objeto e tratar os sinais definidos em MyTimer(), você pode definir quantos sinais forem necessários:

	  self.timer = MyTimer()
	  self.timer.Timer(3) # 3 segundos

	  self.connect(self.timer,
                       QtCore.SIGNAL("sinal_stualiza()"),
                       self.atualiza)
	  # caso seja necessario executar algo após o termino da
          # therad (não é o caso do exemplo acima que o while
          # "trava" na função run()
	  self.connect(self.timer,
                       QtCore.SIGNAL("finished()"),
                       self.finaliza)

Contudo existe uma maneira muito mais fácil de fazer um timer utilizando PyQT, usando a QTimer

	self.timer = QtCore.QTimer()

	self.connect(self.timer,
                     QtCore.SIGNAL("timeout()"),
                     self.atualiza)

        self.timer.start(3000) # tempo em milisegundos

Basicamente o que distingue uma distribuição GNU/Linux é a maneira como os programas são instalados ou removidos. Eis alguns exemplos :

• yum – gerencia e instala os pacotes no Fedora (extensão .rpm)
• apt – cuida dos pacotes no Debian, Ubuntu, Knoppix, Kurumin etc (extensão .deb)
• pacman – utilizado no Arch Linux
• emerge -  do sistema Portage, que compila e instala os pacotes no Gentoo.

1. Gentoo

Searching…
[ Results for search key : openoffice ]
[ Applications found : 2 ]

*  app-office/openoffice
Latest version available: 3.0.1
Latest version installed: [ Not Installed ]
Size of files: 364,086 kB
Homepage:      http://go-oo.org
Description:   OpenOffice.org, a full office productivity suite.
License:       LGPL-2

*  app-office/openoffice-bin
Latest version available: 3.0.1
Latest version installed: 3.0.0
Size of files: 1,575,091 kB
Homepage:      http://www.openoffice.org/
Description:   OpenOffice productivity suite
License:       LGPL-2

2. Fedora

Geladene Plugins: fastestmirror, refresh-packagekit
============================= Matched: openoffice ==============================
broffice.org-base.i386 : Database frontend for BrOffice.org
broffice.org-brand.i386 : Core brand for BrOffice.org
broffice.org-calc.i386 : Spreadsheet module for BrOffice.org
broffice.org-draw.i386 : Drawing module for BrOffice.org
broffice.org-impress.i386 : Presentation module for BrOffice.org
broffice.org-math.i386 : Equation editor module for BrOffice.org
broffice.org-writer.i386 : Word Processor module for BrOffice.org
openoffice.org-base.i386 : Database frontend for openoffice.org
openoffice.org-base-core.i386 : Database GUI libraries for openoffice.org
openoffice.org-brand.i386 : Core brand for openoffice.org
openoffice.org-bsh.i386 : BeanShell support for openoffice.org
openoffice.org-calc.i386 : Spreadsheet module for openoffice.org
openoffice.org-calc-core.i386 : Spreadsheet libraries for openoffice.org
openoffice.org-core.i386 : Core modules for openoffice.org
openoffice.org-devel.i386 : Development Libraries for openoffice.org
openoffice.org-draw.i386 : Drawing module for openoffice.org
openoffice.org-draw-core.i386 : Drawing libraries for openoffice.org
openoffice.org-emailmerge.i386 : Email mail merge component for openoffice.org
openoffice.org-graphicfilter.i386 : Extra graphic filters for openoffice.org
openoffice.org-headless.i386 : Headless plugin for openoffice.org
openoffice.org-impress.i386 : Presentation module for openoffice.org
openoffice.org-impress-core.i386 : Presentation libraries for openoffice.org
openoffice.org-javafilter.i386 : Extra javafilter module for openoffice.org
(…)
openoffice.org-langpack-pt_BR.i386 : Brazilian Portuguese language pack for  : openoffice.org
(…)
openoffice.org-pyuno.i386 : Python support for openoffice.org
openoffice.org-report-builder.i386 : Create database reports from openoffice.org
openoffice.org-rhino.i386 : JavaScript support for openoffice.org
openoffice.org-sdk.i386 : Software Development Kit for openoffice.org
openoffice.org-sdk-doc.i386 : Software Development Kit documentation for : openoffice.org
openoffice.org-testtools.i386 : Testtools for openoffice.org
openoffice.org-ure.i386 : UNO Runtime Environment
openoffice.org-writer.i386 : Word Processor module for openoffice.org
openoffice.org-writer-core.i386 : Word Processor libraries for openoffice.org
(…)
kdocker.i386 : Dock any application in the system tray
keyjnote.noarch : A program that displays presentation slides
latex2emf.i386 : Create an EMF file from LaTeX source
mythes-cs.noarch : Czech thesarus
o3read.i386 : Standalone converter for OpenOffice.org documents
odt2txt.i386 : Converts an OpenDocument to plain text
ooo2txt.noarch : Convert OpenOffice documents to simple text
oooqs2.i386 : OpenOffice.org Quickstarter 2
(…)

3. ArchLinux

extra/openoffice-base 3.0.1-1
OpenOffice.org – a free multiplatform and multilingual office suite
extra/openoffice-base-beta 3.1.0_ooo310_m1-1
OpenOffice.org – a free multiplatform and multilingual office suite
extra/openoffice-base-devel 3.2_dev300_m41-1
OpenOffice.org – a free multiplatform and multilingual office suite
(…)
extra/openoffice-pt_br 3.0.1-1
OpenOffice portugese brazil language files
(…)
community/openoffice-sr 3.0.1-1
OpenOffice Serbian language files
community/openoffice-tr 3.0.1-1
OpenOffice Turkish language files
community/openoffice-uk 3.0.1-1
OpenOffice Ukrainian language files

4.Ubuntu

dictionaries-common – Common utilities for spelling dictionary tools
dmake – make utility used to build OpenOffice.org
gnumeric – spreadsheet application for GNOME – main program
hunspell – spell checker and morphological analyzer (program)
hunspell-de-at – Austrian (German) dictionary for hunspell
hunspell-de-ch – Swiss (German) dictionary for hunspell
hunspell-de-de – German dictionary for hunspell
hunspell-tools – tools for hunspell
language-pack-byn-base – translations for language Blin; Bilin
language-pack-kde-no-base – KDE translations for language Norwegian
(…)
language-support-en – metapackage for English language support
language-support-eo – metapackage for Esperanto language support
language-support-es – metapackage for Spanish; Castilian language support
(…)
language-support-pt – metapackage for Portuguese language support
language-support-ro – metapackage for Romanian language support
language-support-ru – metapackage for Russian language support
(…)
language-support-translations-af – Additional translations metapackage for Afrikaans
language-support-translations-ar – Additional translations metapackage for Arabic
language-support-translations-as – Additional translations metapackage for Assamese
(…)
language-support-translations-zh – Additional translations metapackage for Chinese
language-support-translations-zu – Additional translations metapackage for Zulu
language-support-ts – metapackage for Tsonga language support
language-support-uk – metapackage for Ukrainian language support
(…)
language-support-zu – metapackage for Zulu language support
libhunspell-1.1-0 – spell checker and morphological analyzer (shared library)
libhunspell-dev – spell checker and morphological analyzer (development)
libhyphen-dev – ALTLinux hyphenation library – development files
libhyphen0 – ALTLinux hyphenation library – shared library
libuno-cil – CLI binding for OpenOffice.org
myspell-bg – The Bulgarian dictionary for myspell
(…)
myspell-pt-br – Brazilian Portuguese dictionary for myspell
myspell-pt-pt – European Portuguese dictionary for myspell
(…)
myspell-zu – The Zulu dictionary for myspell
o3read – standalone converter for OpenOffice.org documents
openoffice.org-hyphenation – Hyphenation patterns for OpenOffice.org
openoffice.org-hyphenation-en-us – US English hyphenation patterns for OpenOffice.org
(…)
openoffice.org-thesaurus-pl – Polish Thesaurus for OpenOffice.org
translate-toolkit – Toolkit assisting in the localization of software
bkchem – Python based chemical structures editor
docbook2odf – XSLT based conversions from docbook to Oasis Open Document (openoffice.org)
extract – displays meta-data from files of arbitrary type
fig2sxd – convert XFig files to OpenOffice.org format
gkrellm-hdplop – A hard drive activity monitor GKrellM plugin
gnumeric-gtk – spreadsheet application for GNOME – GTK version
gramadoir – Irish language grammar checker (integration scripts)
gramps – Genealogical Research and Analysis Management Program
hunspell-ar – Arabic dictionary for hunspell
hunspell-uz – The Uzbek dictionary for Hunspell
jed – editor for programmers (textmode version)
kdissert – mindmapping tool
kdocker – minimize all applications to system tray
libaltlinuxhyph-dev – ALTLinux hyphenation library development files
libextractor1c2a – extracts meta-data from files of arbitrary type (library)
libooolib-perl – Perl library for creating OpenOffice.org documents (calc/writer)
libspreadsheet-writeexcel-perl – create Excel spreadsheets
lsr – The Linux Screen Reader for GNOME
ming-fonts-opensymbol – Ming format Opensymbol Fonts
(…)
myspell-fi – The Finnish dictionary for myspell
odt2txt – simple converter from OpenDocument Text to plain text
ooo2dbk – converts OpenOffice.org SXW documents to DocBook XML
oooqs2-kde – OpenOffice.org2 QuickStarter applet for KDE
openclipart-openoffice.org – clip art for OpenOffice.org gallery
openoffice.org-ctl-he – Turns on CTL support, & sets Hebrew as the default CTL locale
openoffice.org-ogltrans – OpenOffice.org “OpenGL rendered transitions” extension
openoffice.org-qa-ui-tests – Test Scripts for the OpenOffice.org Testtool
openoffice.org-starter-guide – Getting Started guide for OpenOffice.org 2.x
recoll – A personal full text search package with a QT GUI
strigi-utils – command-line tools for Strigi Desktop Search
swish-e – Simple Web Indexing System for Humans – Enhanced
tex4ht – LaTeX and TeX for Hypertext (HTML) – executables
tex4ht-common – LaTeX and TeX for Hypertext (HTML) – support files
thescoder – compiler for OpenOffice 1.x thesaurus files
unoconv – converter between OpenOffice.org document formats
wmhdplop – A hard drive activity monitor dockapp
wpd2sxw – WordPerfect to OpenOffice.org converter
wps2sxw – Works text documents to OpenOffice.org converter
xjed – editor for programmers (x11 version)
zope-textindexng3 – full text index for Zope objects
zope-textindexng3-lib – full text index for Zope objects
myspell-eu-es – Basque (Euskera) dictionary for myspell
(…)
language-pack-gnome-pl-base – GNOME translations for language Polish
language-pack-gnome-ps-base – GNOME translations for language Pushto
language-pack-gnome-pt-base – GNOME translations for language Portuguese
(…)
language-pack-kde-hy-base – KDE translations for language Armenian
language-pack-kde-ia-base – KDE translations for language Interlingua (International Auxiliary Language Association)
language-pack-kde-id-base – KDE translations for language Indonesian
(…)
language-pack-kde-ps-base – KDE translations for language Pushto
language-pack-kde-pt-base – KDE translations for language Portuguese
(…)
language-pack-pt-base – translations for language Portuguese
(…)
language-pack-zu-base – translations for language Zulu
language-pack-zza-base – translations for language Zaza; Dimili; Dimli; Kirdki; Kirmanjki; Zazaki
libwriter2latex-java-doc – OpenOffice.org Writer/Calc to LaTeX/XHTML converter — javadoc
myspell-af – Afrikaans dictionary for myspell
myspell-en-gb – English_british dictionary for myspell
myspell-en-us – English_american dictionary for myspell
myspell-en-za – English_shouthafrican dictionary for myspell
(…)
openoffice.org – OpenOffice.org Office suite
openoffice.org-base – OpenOffice.org office suite – database
openoffice.org-base-core – OpenOffice.org office suite — libdba
openoffice.org-calc – OpenOffice.org office suite – spreadsheet
openoffice.org-common – OpenOffice.org office suite architecture independent files
openoffice.org-core – OpenOffice.org office suite architecture dependent files
openoffice.org-dev – OpenOffice.org SDK — development files
openoffice.org-dev-doc – OpenOffice.org SDK — documentation
openoffice.org-draw – OpenOffice.org office suite – drawing
openoffice.org-evolution – Evolution Addressbook support for OpenOffice.org
openoffice.org-filter-binfilter – Legacy filters (e.g. StarOffice 5.2) for OpenOffice.org
openoffice.org-filter-mobiledev – Mobile Devices Filters for OpenOffice.org
openoffice.org-gcj – OpenOffice.orgs Java libraries (native for use with GIJ)
openoffice.org-gnome – GNOME Integration for OpenOffice.org (VFS, GConf)
openoffice.org-gtk – GTK+ Integration for OpenOffice.org (Widgets, Dialogs, Quickstarter)
(…)
openoffice.org-help-pt – Portuguese help for OpenOffice.org
(..)
openoffice.org-hyphenation-af – Afrikaans hyphenation patterns for OpenOffice.org
openoffice.org-hyphenation-de – German hyphenation patterns for OpenOffice.org
(…)
openoffice.org-impress – OpenOffice.org office suite – presentation
openoffice.org-java-common – OpenOffice.org office suite Java support arch. independent files
openoffice.org-kde – KDE Integration for OpenOffice.org (Widgets, Dialogs, Addressbook)
(…)
openoffice.org-l10n-pt – Portuguese language package for OpenOffice.org
openoffice.org-l10n-pt-br – Portuguese_brazilian language package for OpenOffice.org
(…)
openoffice.org-voikko – Finnish spell-checker and hyphenation for OpenOffice.org
openoffice.org-writer – OpenOffice.org office suite – word processor
openoffice.org-writer2latex – Writer/Calc to LaTeX/XHTML converter extension for OpenOffice.org
python-uno – Python interface for OpenOffice.org
ttf-opensymbol – The OpenSymbol TrueType font
(…)
broffice.org – BrOffice.org office suite
libwriter2latex-java – OpenOffice.org Writer/Calc to LaTeX/XHTML converter — library
openoffice.org-dtd-officedocument1.0 – OfficeDocument 1.0 DTD (OpenOffice.org 1.x)
openoffice.org-headless – Headless VCL plugin for OpenOffice.org
openoffice.org-presentation-minimizer – OpenOffice.org Presentation Minimizer extension
openoffice.org-report-builder – OpenOffice.org Report Builder extension
openoffice.org-sdbc-postgresql – PostgreSQL SDBC driver for OpenOffice.org
openoffice.org-style-hicontrast – Hicontrast symbol style for OpenOffice.org
writer2latex – OpenOffice.org Writer/Calc to LaTeX/XHTML converter
writer2latex-manual – OpenOffice.org Writer/Calc to LaTeX/XHTML converter — manual

Como podem perceber,  há um excesso de resultados no Ubuntu e no Fedora. Resolvi fazer esse post pois já vi muitos usuários iniciantes no GNU/Linux que optaram, por exemplo, pelo Ubuntu ficarem perdidos quando precisaram instalar o Java ou alguma biblioteca devido as inúmeros pacotes listados. Continuo preferindo a maneira do Gentoo para as buscas, resultado simples e objetivo (podendo ser rápido usando o eix). E você leitor, como faz para organizar seus programas na sua distribuição? As ferramentas gráficas realmente são eficientes para filtrar essa quantidade de resultados?

Hoje tive uma idéia ao ler um artigo intitulado How Compiling Works no qual o autor descreve em linhas gerais, mas de uma maneira interessante, o processo de compilação de um código escrito em C (abordando  o processo de linkagem com as bibliotecas) tomando como exemplo a função printf. Resolvi fazer uma brincadeira, mostrando como isso pode ser realmente implementado na prática, usando chamadas de sistema (syscalls) do Linux, de modo que não seja necessário usar a implementação disponível na glibc.

Começando com um exemplo simples, bem parecido com que todo mundo que um dia pensou em programar já viu.  A diferença que a função printf será modificada para receber apenas caracteres (não variáveis) e a quantidade.

#include "stdio.h"
int main() {

	printf("Hello, world!\n",15);
	return 0;
}

Reparem que o cabeçalho está entre aspas, indicando ao compilador que vamos usar uma implementação particular e não a implementação da glibc, no meu caso os arquivos

• /usr/include/stdio.h (protótipo)
• /usr/lib/libc.so  (implementação)

Serão substituidos pelos arquivos stdio.h e stdio.c abaixo:

#ifndef STDIO_H_
#define STDIO_H_

int printf(char* texto, int tam);

#endif /* STDIO_H_ */

Agora que temos o protótipo da função printf() que é diferente da função printf() que conhecemos mas servirá para esse primeiro exemplo:

#include "stdio.h"

int printf(char* texto, int tam)

{
__asm__ ("movl $0x4,%%eax; \
          movl $0x1,%%ebx; \
          movl %0,%%ecx; \
          movl %1,%%edx; \
          int $0x80": : "g" (texto) , "g" (tam) );

  return 0;
}

Podemos incrementar um pouco mais do código em assembly, para não precisar estipular o número de caracteres.

__asm__ ("      xorl %%edx,%%edx; \
                xorl %%eax,%%eax; \

                movl %0,%%ecx; \
        loop:   movb (%%ecx,%%edx),%%al; \
                incl %%edx; \
                test %%al,%%al; \
                jnz loop; \
                decl %%edx; \

                movl $0x4,%%eax; \
                movl $0x1,%%ebx; \
                int $0x80": : "g" (texto));

Para fazer uma função equivalente ao printf() da glibc precisaríamos implementar o suporte a múltiplos argumentos e mais um monte de coisas Fiz um esboço de uma idéia do printf, mas ainda usando funções da glibc apenas implementando a syscall write.

#include <stdlib.h>
#include <stdarg.h>
#include <string.h>

#define _write(texto, d) 
__asm__ ("movl $0x4,%%eax; \
	  movl $0x1,%%ebx; \
	  movl %0,%%ecx; \
	  movl %1,%%edx; \

	  int $0x80": : "g" (texto) , "g" (d) );

int write(char *fmt, ...);

int main(){

	char *index=malloc(2);
	char *nome=malloc(20);

	strcpy(index,"19");
	strcpy(nome,"Escovando Bits !!!");

	write("blog: %s \nindex: %s\n",nome,index);

	return 0;
}

int write(char *fmt, ...) {

	char *s;
	va_list ap;
	register int d=0,tam;

	int size;

	va_start(ap, fmt );
	tam = strlen(fmt);

	for (d=0; d<tam; d++, *++fmt) {

		if (*fmt != '%' ) {

		_write(fmt,1);
		} else {

			switch (*++fmt) {
			case 's': {
				s = va_arg(ap, char *);

				size = strlen(s);
				_write(s,size);
			break;
			} // fim case
			} // fim switch

		} // fim else
	} // fim for

	va_end(ap);
	return(1);
}

Se analisarmos o código-fonte da glibc veremos que sua implementação é completamente diferente da proposta nesse post, por questões de portabilidade de hardware, segurança, elegância, desempenho, etc;  Um exemplo é a possiblidade de criar extensões para a função printf.

Bom, essa foi a primeira entrada do ano aqui no EscovandoBits,  mais novidades para os próximos dias, com a cobertura do Mauro sobre a Campus Party que acontece do dia 19 a 25 de Janeiro.

Posted in programação Tagged: c, glibc, kernel, Linux, syscalls ]]> http://escovandobits.wordpress.com/2009/01/21/exemplos-do-uso-syscalls-x86-do-linux/feed/ 0 Tiago Maluta http://escovandobits.wordpress.com/2008/11/02/montando-imagens-jffs2/ http://escovandobits.wordpress.com/2008/11/02/montando-imagens-jffs2/#comments Sun, 02 Nov 2008 13:58:40 +0000 Tiago Maluta http://escovandobits.wordpress.com/?p=240 ]]>

Partições em JFFS2 são encontradas em um vasto número de sistemas embarcados. Esse post mostra como montar uma imagem JFFS2 na própria RAM. Muito útil para analisar seu conteúdo de firmwares.

O sistema de arquivos JFFS2 não permite que seja montado um através de um loop device, portanto para solucionar esse problema vamos emular um dispostivo MTD na memória RAM. O módulo que faz isso é o mtdram. Fiz o teste em um Fedora e lá todos os módulos já estavam disponíveis, assim dê um modprobe em algum dos módulos descritos logo abaixo e veja se seu sistema possui. Caso seja necessário compilar o kernel, é preciso ativar no .config as opções:

CONFIG_MTD=m
CONFIG_MTD_BLOCK=m
CONFIG_MTD_MTDRAM=m

Vamos ao que interessa:

modprobe mtd
modprobe mtdblock
modprobe mtdram total_size=10240 erase_size=128
dd if=imagem.jffs2 of=/dev/mtdblock0
mount -t jffs2 /dev/mtdblock0 /diretório-qualquer

O prático dessa história é que podemos definir o tamanho total do dispositivo MTD bem como o tamanho do erease block. Também há como deixar pré-definido no kernel esses tamanhos.

Obs. Não esqueça de habilitar o suporte ao jffs2 para fazer os testes

Update: Se houver a necessidade de converter uma imagem no formato big endian para little endian (principalmente para montar em máquinas x86) utilize o comando jffs2dump.

jffs2dump -b big_endian.img -e new_little_endian.img

Posted in Linux, Sistemas Embarcados Tagged: jffs2, Linux, mtd ]]> http://escovandobits.wordpress.com/2008/11/02/montando-imagens-jffs2/feed/ 2 Tiago Maluta MTD logo