answer
stringlengths 15
1.25M
|
|---|
/*
* blockio.cc
*
*
*/
#define _LARGEFILE_SOURCE
#define _FILE_OFFSET_BITS 64
#include "version.h"
#include "blockio.h"
#include "osutils.h"
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdint.h>
__ID("@(#) $Id: blockio.cc 2069 2009-02-12 22:53:09Z lyonel $");
ssize_t readlogicalblocks(source & s,
void * buffer,
long long pos, long long count)
{
long long result = 0;
memset(buffer, 0, count*s.blocksize);
/* attempt to read past the end of the section */
if((s.size>0) && ((pos+count)*s.blocksize>s.size)) return 0;
result = lseek(s.fd, s.offset + pos*s.blocksize, SEEK_SET);
if(result == -1) return 0;
result = read(s.fd, buffer, count*s.blocksize);
if(result!=count*s.blocksize)
return 0;
else
return count;
}
|
#include <math.h>
#include "vec3.h"
#include "common.h"
#include "solid_vary.h"
#include "solid_sim.h"
#include "solid_all.h"
#include "solid_cmd.h"
#define LARGE 1.0e+5f
#define SMALL 1.0e-3f
/* Solves (p + v * t) . (p + v * t) == r * r for smallest t. */
/*
* Given vectors A = P, B = V * t, C = A + B, |C| = r, solve for
* smallest t.
*
* Some useful dot product properties:
*
* 1) A . A = |A| * |A|
* 2) A . (B + C) = A . B + A . C
* 3) (r * A) . B = r * (A . B)
*
* Deriving a quadratic equation:
*
* C . C = r * r (1)
* (A + B) . (A + B) = r * r
* A . (A + B) + B . (A + B) = r * r (2)
* A . A + A . B + B . A + B . B = r * r (2)
* A . A + 2 * (A . B) + B . B = r * r
* P . P + 2 * (P . V * t) + (V * t . V * t) = r * r
* P . P + 2 * (P . V) * t + (V . V) * t * t = r * r (3)
* (V . V) * t * t + 2 * (P . V) * t + P . P - r * r = 0
*
* This equation is solved using the quadratic formula.
*/
static float v_sol(const float p[3], const float v[3], float r)
{
float a = v_dot(v, v);
float b = v_dot(v, p) * 2.0f;
float c = v_dot(p, p) - r * r;
float d = b * b - 4.0f * a * c;
/* HACK: This seems to cause failures to detect low-velocity collision
Yet, the potential division by zero below seems fine.
if (fabsf(a) < SMALL) return LARGE;
*/
if (d < 0.0f) return LARGE;
else if (d > 0.0f)
{
float t0 = 0.5f * (-b - fsqrtf(d)) / a;
float t1 = 0.5f * (-b + fsqrtf(d)) / a;
float t = (t0 < t1) ? t0 : t1;
return (t < 0.0f) ? LARGE : t;
}
else return -b * 0.5f / a;
}
/*
* Compute the earliest time and position of the intersection of a
* sphere and a vertex.
*
* The sphere has radius R and moves along vector V from point P. The
* vertex moves along vector W from point Q in a coordinate system
* based at O.
*/
static float v_vert(float Q[3],
const float o[3],
const float q[3],
const float w[3],
const float p[3],
const float v[3], float r)
{
float O[3], P[3], V[3];
float t = LARGE;
v_add(O, o, q);
v_sub(P, p, O);
v_sub(V, v, w);
if (v_dot(P, V) < 0.0f)
{
t = v_sol(P, V, r);
if (t < LARGE)
v_mad(Q, O, w, t);
}
return t;
}
/*
* Compute the earliest time and position of the intersection of a
* sphere and an edge.
*
* The sphere has radius R and moves along vector V from point P. The
* edge moves along vector W from point Q in a coordinate system based
* at O. The edge extends along the length of vector U.
*/
static float v_edge(float Q[3],
const float o[3],
const float q[3],
const float u[3],
const float w[3],
const float p[3],
const float v[3], float r)
{
float d[3], e[3];
float P[3], V[3];
float du, eu, uu, s, t;
v_sub(d, p, o);
v_sub(d, d, q);
v_sub(e, v, w);
/*
* Think projections. Vectors D, extending from the edge vertex Q
* to the sphere, and E, the relative velocity of sphere wrt the
* edge, are made orthogonal to the edge vector U. Division of
* the dot products is required to obtain the true projection
* ratios since U does not have unit length.
*/
du = v_dot(d, u);
eu = v_dot(e, u);
uu = v_dot(u, u);
v_mad(P, d, u, -du / uu);
/* First, test for intersection. */
if (v_dot(P, P) < r * r)
{
/* The sphere already intersects the line of the edge. */
if (du < 0 || du > uu)
{
/*
* The sphere is behind the endpoints of the edge, and
* can't hit the edge without hitting the vertices first.
*/
return LARGE;
}
/* The sphere already intersects the edge. */
if (v_dot(P, e) >= 0)
{
/* Moving apart. */
return LARGE;
}
v_nrm(P, P);
v_mad(Q, p, P, -r);
return 0;
}
v_mad(V, e, u, -eu / uu);
t = v_sol(P, V, r);
s = (du + eu * t) / uu; /* Projection of D + E * t on U. */
if (0.0f <= t && t < LARGE && 0.0f < s && s < 1.0f)
{
v_mad(d, o, w, t);
v_mad(e, q, u, s);
v_add(Q, e, d);
}
else
t = LARGE;
return t;
}
/*
* Compute the earliest time and position of the intersection of a
* sphere and a plane.
*
* The sphere has radius R and moves along vector V from point P. The
* plane moves along vector W. The plane has normal N and is
* positioned at distance D from the origin O along that normal.
*/
static float v_side(float Q[3],
const float o[3],
const float w[3],
const float n[3], float d,
const float p[3],
const float v[3], float r)
{
float vn = v_dot(v, n);
float wn = v_dot(w, n);
float t = LARGE;
if (vn - wn <= 0.0f)
{
float on = v_dot(o, n);
float pn = v_dot(p, n);
float u = (r + d + on - pn) / (vn - wn);
float a = ( d + on - pn) / (vn - wn);
if (0.0f <= u)
{
t = u;
v_mad(Q, p, v, +t);
v_mad(Q, Q, n, -r);
}
else if (0.0f <= a)
{
t = 0;
v_mad(Q, p, v, +t);
v_mad(Q, Q, n, -r);
}
}
return t;
}
/*
* Compute the new linear and angular velocities of a bouncing ball.
* Q gives the position of the point of impact and W gives the
* velocity of the object being impacted.
*/
static float sol_bounce(struct v_ball *up,
const float q[3],
const float w[3], float dt)
{
float n[3], r[3], d[3], vn, wn;
float *p = up->p;
float *v = up->v;
/* Find the normal of the impact. */
v_sub(r, p, q);
v_sub(d, v, w);
v_nrm(n, r);
/* Find the new angular velocity. */
v_crs(up->w, d, r);
v_scl(up->w, up->w, -1.0f / (up->r * up->r));
/* Find the new linear velocity. */
vn = v_dot(v, n);
wn = v_dot(w, n);
v_mad(v, v, n, 1.7 * (wn - vn));
v_mad(p, q, n, up->r);
/* Return the "energy" of the impact, to determine the sound amplitude. */
return fabsf(v_dot(n, d));
}
static float sol_test_vert(float dt,
float T[3],
const struct v_ball *up,
const struct b_vert *vp,
const float o[3],
const float w[3])
{
return v_vert(T, o, vp->p, w, up->p, up->v, up->r);
}
static float sol_test_edge(float dt,
float T[3],
const struct v_ball *up,
const struct s_base *base,
const struct b_edge *ep,
const float o[3],
const float w[3])
{
float q[3];
float u[3];
v_cpy(q, base->vv[ep->vi].p);
v_sub(u, base->vv[ep->vj].p, base->vv[ep->vi].p);
return v_edge(T, o, q, u, w, up->p, up->v, up->r);
}
static float sol_test_side(float dt,
float T[3],
const struct v_ball *up,
const struct s_base *base,
const struct b_lump *lp,
const struct b_side *sp,
const float o[3],
const float w[3])
{
float t = v_side(T, o, w, sp->n, sp->d, up->p, up->v, up->r);
int i;
if (t < dt)
for (i = 0; i < lp->sc; i++)
{
const struct b_side *sq = base->sv + base->iv[lp->s0 + i];
if (sp != sq &&
v_dot(T, sq->n) -
v_dot(o, sq->n) -
v_dot(w, sq->n) * t > sq->d)
return LARGE;
}
return t;
}
static int sol_test_fore(float dt,
const struct v_ball *up,
const struct b_side *sp,
const float o[3],
const float w[3])
{
float q[3], d;
/* If the ball is not behind the plane, the test passes. */
v_sub(q, up->p, o);
d = sp->d;
if (v_dot(q, sp->n) - d + up->r >= 0)
return 1;
/* If it's not behind the plane after DT seconds, the test passes. */
v_mad(q, q, up->v, dt);
d += v_dot(w, sp->n) * dt;
if (v_dot(q, sp->n) - d + up->r >= 0)
return 1;
/* Else, test fails. */
return 0;
}
static int sol_test_back(float dt,
const struct v_ball *up,
const struct b_side *sp,
const float o[3],
const float w[3])
{
float q[3], d;
/* If the ball is not in front of the plane, the test passes. */
v_sub(q, up->p, o);
d = sp->d;
if (v_dot(q, sp->n) - d - up->r <= 0)
return 1;
/* If it's not in front of the plane after DT seconds, the test passes. */
v_mad(q, q, up->v, dt);
d += v_dot(w, sp->n) * dt;
if (v_dot(q, sp->n) - d - up->r <= 0)
return 1;
/* Else, test fails. */
return 0;
}
static float sol_test_lump(float dt,
float T[3],
const struct v_ball *up,
const struct s_base *base,
const struct b_lump *lp,
const float o[3],
const float w[3])
{
float U[3] = { 0.0f, 0.0f, 0.0f };
float u, t = dt;
int i;
/* Short circuit a non-solid lump. */
if (lp->fl & L_DETAIL) return t;
/* Test all verts */
if (up->r > 0.0f)
for (i = 0; i < lp->vc; i++)
{
const struct b_vert *vp = base->vv + base->iv[lp->v0 + i];
if ((u = sol_test_vert(t, U, up, vp, o, w)) < t)
{
v_cpy(T, U);
t = u;
}
}
/* Test all edges */
if (up->r > 0.0f)
for (i = 0; i < lp->ec; i++)
{
const struct b_edge *ep = base->ev + base->iv[lp->e0 + i];
if ((u = sol_test_edge(t, U, up, base, ep, o, w)) < t)
{
v_cpy(T, U);
t = u;
}
}
/* Test all sides */
for (i = 0; i < lp->sc; i++)
{
const struct b_side *sp = base->sv + base->iv[lp->s0 + i];
if ((u = sol_test_side(t, U, up, base, lp, sp, o, w)) < t)
{
v_cpy(T, U);
t = u;
}
}
return t;
}
static float sol_test_node(float dt,
float T[3],
const struct v_ball *up,
const struct s_base *base,
const struct b_node *np,
const float o[3],
const float w[3])
{
float U[3], u, t = dt;
int i;
/* Test all lumps */
for (i = 0; i < np->lc; i++)
{
const struct b_lump *lp = base->lv + np->l0 + i;
if ((u = sol_test_lump(t, U, up, base, lp, o, w)) < t)
{
v_cpy(T, U);
t = u;
}
}
/* Test in front of this node */
if (np->ni >= 0 && sol_test_fore(t, up, base->sv + np->si, o, w))
{
const struct b_node *nq = base->nv + np->ni;
if ((u = sol_test_node(t, U, up, base, nq, o, w)) < t)
{
v_cpy(T, U);
t = u;
}
}
/* Test behind this node */
if (np->nj >= 0 && sol_test_back(t, up, base->sv + np->si, o, w))
{
const struct b_node *nq = base->nv + np->nj;
if ((u = sol_test_node(t, U, up, base, nq, o, w)) < t)
{
v_cpy(T, U);
t = u;
}
}
return t;
}
static float sol_test_body(float dt,
float T[3], float V[3],
const struct v_ball *up,
const struct s_vary *vary,
const struct v_body *bp)
{
float U[3], O[3], E[4], W[3], u;
const struct b_node *np = vary->base->nv + bp->base->ni;
sol_body_p(O, vary, bp, 0.0f);
sol_body_v(W, vary, bp, dt);
sol_body_e(E, vary, bp, 0.0f);
/*
* For rotating bodies, rather than rotate every normal and vertex
* of the body, we temporarily pretend the ball is rotating and
* moving about a static body.
*/
/*
* Linear velocity of a point rotating about the origin:
* v = w x p
*/
if (E[0] != 1.0f || sol_body_w(vary, bp))
{
/* The body has a non-identity orientation or it is rotating. */
struct v_ball ball;
float e[4], p0[3], p1[3];
const float z[3] = { 0 };
/* First, calculate position at start and end of time interval. */
v_sub(p0, up->p, O);
v_cpy(p1, p0);
q_conj(e, E);
q_rot(p0, e, p0);
v_mad(p1, p1, up->v, dt);
v_mad(p1, p1, W, -dt);
sol_body_e(e, vary, bp, dt);
q_conj(e, e);
q_rot(p1, e, p1);
/* Set up ball struct with values relative to body. */
ball = *up;
v_cpy(ball.p, p0);
/* Calculate velocity from start/end positions and time. */
v_sub(ball.v, p1, p0);
v_scl(ball.v, ball.v, 1.0f / dt);
if ((u = sol_test_node(dt, U, &ball, vary->base, np, z, z)) < dt)
{
/* Compute the final orientation. */
sol_body_e(e, vary, bp, u);
/* Return world space coordinates. */
q_rot(T, e, U);
v_add(T, O, T);
/* Move forward. */
v_mad(T, T, W, u);
/* Express "non-ball" velocity. */
q_rot(V, e, ball.v);
v_sub(V, up->v, V);
dt = u;
}
}
else
{
if ((u = sol_test_node(dt, U, up, vary->base, np, O, W)) < dt)
{
v_cpy(T, U);
v_cpy(V, W);
dt = u;
}
}
return dt;
}
static float sol_test_file(float dt,
float T[3], float V[3],
const struct v_ball *up,
const struct s_vary *vary)
{
float U[3], W[3], u, t = dt;
int i;
for (i = 0; i < vary->bc; i++)
{
const struct v_body *bp = vary->bv + i;
if ((u = sol_test_body(t, U, W, up, vary, bp)) < t)
{
v_cpy(T, U);
v_cpy(V, W);
t = u;
}
}
return t;
}
/*
* Track simulation steps in integer milliseconds.
*/
static float ms_accum;
static void ms_init(void)
{
ms_accum = 0.0f;
}
static int ms_step(float dt)
{
int ms = 0;
ms_accum += dt;
while (ms_accum >= 0.001f)
{
ms_accum -= 0.001f;
ms += 1;
}
return ms;
}
static int ms_peek(float dt)
{
int ms = 0;
float at;
at = ms_accum + dt;
while (at >= 0.001f)
{
at -= 0.001f;
ms += 1;
}
return ms;
}
/*
* Step the physics forward DT seconds under the influence of gravity
* vector G. If the ball gets pinched between two moving solids, this
* loop might not terminate. It is better to do something physically
* impossible than to lock up the game. So, if we make more than C
* iterations, punt it.
*/
float sol_step(struct s_vary *vary, const float *g, float dt, int ui, int *m)
{
float P[3], V[3], v[3], r[3], a[3], d, e, nt, b = 0.0f, tt = dt;
int c;
union cmd cmd;
if (ui < vary->uc)
{
struct v_ball *up = vary->uv + ui;
/* If the ball is in contact with a surface, apply friction. */
v_cpy(a, up->v);
v_cpy(v, up->v);
v_cpy(up->v, g);
if (m && sol_test_file(tt, P, V, up, vary) < 0.0005f)
{
v_cpy(up->v, v);
v_sub(r, P, up->p);
if ((d = v_dot(r, g) / (v_len(r) * v_len(g))) > 0.999f)
{
if ((e = (v_len(up->v) - dt)) > 0.0f)
{
/* Scale the linear velocity. */
v_nrm(up->v, up->v);
v_scl(up->v, up->v, e);
/* Scale the angular velocity. */
v_sub(v, V, up->v);
v_crs(up->w, v, r);
v_scl(up->w, up->w, -1.0f / (up->r * up->r));
}
else
{
/* Friction has brought the ball to a stop. */
up->v[0] = 0.0f;
up->v[1] = 0.0f;
up->v[2] = 0.0f;
(*m)++;
}
}
else v_mad(up->v, v, g, tt);
}
else v_mad(up->v, v, g, tt);
/* Test for collision. */
for (c = 16; c > 0 && tt > 0; c
{
float st;
int mi, ms;
/* HACK: avoid stepping across path changes. */
st = tt;
for (mi = 0; mi < vary->mc; mi++)
{
struct v_move *mp = vary->mv + mi;
struct v_path *pp = vary->pv + mp->pi;
if (!pp->f)
continue;
if (mp->tm + ms_peek(st) > pp->base->tm)
st = MS_TO_TIME(pp->base->tm - mp->tm);
}
/* Miss collisions if we reach the iteration limit. */
if (c > 1)
nt = sol_test_file(st, P, V, up, vary);
else
nt = tt;
cmd.type = CMD_STEP_SIMULATION;
cmd.stepsim.dt = nt;
sol_cmd_enq(&cmd);
ms = ms_step(nt);
sol_move_step(vary, nt, ms);
sol_swch_step(vary, nt, ms);
sol_ball_step(vary, nt);
if (nt < st)
if (b < (d = sol_bounce(up, P, V, nt)))
b = d;
tt -= nt;
}
v_sub(a, up->v, a);
sol_pendulum(up, a, g, dt);
}
return b;
}
void sol_init_sim(struct s_vary *vary)
{
ms_init();
}
void sol_quit_sim(void)
{
return;
}
|
package net.pms.medialibrary.commons.dataobjects;
import net.pms.medialibrary.commons.enumarations.ThumbnailPrioType;
public class DOThumbnailPriority {
private long id;
private ThumbnailPrioType <API key>;
private String picturePath;
private int seekPosition;
private int priorityIndex;
public DOThumbnailPriority(){
this(-1, ThumbnailPrioType.THUMBNAIL, "", 0);
}
public DOThumbnailPriority(long id, ThumbnailPrioType <API key>, String picturePath, int priorityIndex){
this(id, <API key>, -1, picturePath, priorityIndex);
}
public DOThumbnailPriority(long id, ThumbnailPrioType <API key>, int seekPosition, int priorityIndex){
this(id, <API key>, seekPosition, "", priorityIndex);
}
public DOThumbnailPriority(long id, ThumbnailPrioType <API key>, int seekPosition, String picturePath, int priorityIndex){
setId(id);
<API key>(<API key>);
setSeekPosition(seekPosition);
setPicturePath(picturePath);
setPriorityIndex(priorityIndex);
}
public void <API key>(ThumbnailPrioType <API key>) {
this.<API key> = <API key>;
}
public ThumbnailPrioType <API key>() {
return <API key>;
}
public void setPicturePath(String picturePath) {
this.picturePath = picturePath;
}
public String getPicturePath() {
return picturePath;
}
public void setSeekPosition(int seekPosition) {
this.seekPosition = seekPosition;
}
public int getSeekPosition() {
return seekPosition;
}
public void setPriorityIndex(int priorityIndex) {
this.priorityIndex = priorityIndex;
}
public int getPriorityIndex() {
return priorityIndex;
}
public void setId(long id) {
this.id = id;
}
public long getId() {
return id;
}
@Override
public boolean equals(Object obj){
if(!(obj instanceof DOThumbnailPriority)){
return false;
}
DOThumbnailPriority compObj = (DOThumbnailPriority) obj;
if(getId() == compObj.getId()
&& <API key>() == compObj.<API key>()
&& getPicturePath().equals(compObj.getPicturePath())
&& getSeekPosition() == compObj.getSeekPosition()
&& getPriorityIndex() == compObj.getPriorityIndex()){
return true;
}
return false;
}
@Override
public int hashCode(){
int hashCode = 24 + String.valueOf(getId()).hashCode();
hashCode *= 24 + getPicturePath().hashCode();
hashCode *= 24 + getSeekPosition();
hashCode *= 24 + getPriorityIndex();
return hashCode;
}
@Override
public DOThumbnailPriority clone(){
return new DOThumbnailPriority(getId(), <API key>(), getSeekPosition(), getPicturePath(), getPriorityIndex());
}
@Override
public String toString(){
return String.format("id=%s, prioIndex=%s, type=%s, seekPos=%s, picPath=%s", getId(), getPriorityIndex(), <API key>(), getSeekPosition(), getPicturePath());
}
}
|
#ifndef TBLSTAILER_H
#define TBLSTAILER_H
#include "TableTailer.h"
#include "tables/hive/TBLSTable.h"
#include "tables/hive/SDSTable.h"
#include "tables/hive/TABCOLSTATSTable.h"
#include "tables/hive/TABLEPARAMSTable.h"
class TBLSTailer : public TableTailer<TBLSRow> {
public:
TBLSTailer(Ndb *ndb, const int poll_maxTimeToWait, const Barrier barrier)
: TableTailer(ndb, new TBLSTable(), poll_maxTimeToWait, barrier) {}
virtual ~TBLSTailer() {}
private:
SDSTable mSDSTable;
TABLEPARAMSTable mTABLEPARAMSTable;
TABCOLSTATSTable mTABCOLSTATSTable;
virtual void handleEvent(NdbDictionary::Event::TableEvent eventType, TBLSRow
pre, TBLSRow row) {
LOG_INFO("Delete TBLS event received. Primary Key value: " << pre.mTBLID);
mTABLEPARAMSTable.remove(mNdbConnection, pre.mTBLID);
mTABCOLSTATSTable.remove(mNdbConnection, pre.mTBLID);
mSDSTable.remove(mNdbConnection, pre.mSDID);
}
};
#endif /* TBLSTAILER_H */
|
#!/bin/sh
. ${srcdir}/tests/common.shi
${RUNENV} ${MEMCHECK} ./rwfile ${SRCDIR}/input_truecolor16.dpx PPM
|
package cmd
import (
"github.com/spf13/cobra"
)
// rotateCmd represents the shuffletips command
var rotateCmd = &cobra.Command{
Use: "rotate",
Short: "Rotates children of internal nodes",
Long: `Rotates children of internal nodes by different means.
Either randomly with "rand" subcommand, either sorting by number of tips
with "sort" subcommand.
It does not change the topology, but just the order of neighbors
of all node and thus the newick representation.
x |z x |z
A
|t |t
Example of usage:
gotree rotate rand -i t.nw
gotree rotate sort -i t.nw
`,
}
func init() {
RootCmd.AddCommand(rotateCmd)
rotateCmd.PersistentFlags().StringVarP(&intreefile, "input", "i", "stdin", "Input tree")
rotateCmd.PersistentFlags().StringVarP(&outtreefile, "output", "o", "stdout", "Rotated tree output file")
}
|
#ifndef <API key>
#define <API key>
/**
* Includes
*/
#include <stdint.h> // STD IEEE Type Definitions - int16_t, uint8_t, etc.
/**
* External Global Routines
*/
extern int16_t emfio_setupCommands();
extern int16_t <API key>();
extern int16_t <API key>();
extern int16_t <API key>();
extern uint32_t <API key>();
extern uint32_t <API key>();
#endif
|
<div class="header"><h1 class="slidetitle">Make the most of the web</h1></div>
<div class="main">
<div class="text">
<div>
<p>Ubuntu MATE includes Firefox, the web browser used by millions of people around the world. And web applications you use frequently (like Facebook or Gmail, for example) can be pinned to your desktop for faster access, just like apps on your computer.</p>
</div>
<div class="featured">
<h2 class="subtitle">Included software</h2>
<ul>
<li>
<img class="icon" src="icons/firefox.png" />
<p class="caption">Firefox web browser</p>
</li>
<li>
<img class="icon" src="icons/thunderbird.png" />
<p class="caption">Thunderbird Mail
</p>
</li>
</ul>
<h2 class="subtitle">Supported software</h2>
<ul>
<li>
<img class="icon" src="icons/chromium.png" />
<p class="caption">Chromium</p>
</li>
</ul>
</div>
</div>
<img class="screenshot" src="screenshots/06_browse.jpg" />
</div>
|
<?php include_once('sites/all/themes/artonair/custom_functions/custom_variable.php'); /* mp3 folder path */ ?>
<?php include_once('sites/all/themes/artonair/custom_functions/default_image.php'); /* function for displaying default images */ ?>
<?php $listen_url = "/drupal/play/" . $node->nid . "/" . $node->path; ?>
<?php global $base_url;
$vgvr = <API key>('archive_popular', 'default');
$node_status = "";
foreach($vgvr as $vresult) {
if($vresult->nid == $node->nid) $node_status = "Popular!";
}
?>
<div class="<?php print $node->type; ?>-body bodyview <?php
foreach($node->taxonomy as $term) {
$your_vocabulary_id = 108;
if ($term->vid == $your_vocabulary_id) {
print $term->name;
}
} ?>">
<div class="content-section">
<div class="left-column" id="header-info">
<div class="header">
<div class="info">
<?php // if($node->field_series[0]['view']) { ?>
<!-- <h6 class="type">
<span><?php// print l("Radio Show", "radio"); ?></span>ABC</h6>
<h6 class="dates"><?php //print $node->field_series[0]['view']; ?></h6>-->
<?php
<?php // if($node->type == "series") { ?>
<!-- <span><?php // print l("Radio Series", "radio/series"); ?></span><?php $view = views_get_view('series_contents');
$args = array($node->nid);
$view->set_display('default', $args); // like 'block_1'
$view->render(); ?>
<div class="episode-count"><?php // print sizeof($view->result);?> Episodes</div>
<?php
<?php // if($node->type == "news") { ?>
<!-- <span><?php // print l("Radio", "radio"); ?></span>Featured Shows This Week -->
<?php
<?php if($node->type == "blog") { ?>
<h6 class="type"><span><?php print l("News", "news"); ?></span></h6>
<h6 class="dates"> <?php
foreach($node->taxonomy as $term) {
$your_vocabulary_id = 108;
if ($term->vid == $your_vocabulary_id) {
print $term->name;
}
} ?></h6>
<?php } ?>
<?php if($node->type == "host") { ?>
<span><?php print l("People", "radio/hosts"); ?></span><?php $view = views_get_view('series_contents');
$args = array($node->nid);
$view->set_display('default', $args); // like 'block_1'
$view->render(); ?>
<div class="episode-count"><?php print sizeof($view->result);?> Programs</div>
<?php } ?>
</h6><!-- /.type -->
<?php if($node->type != "news") { ?>
<div class="title">
<h1><?php print $node->title; ?></h1>
</div><!-- /.title -->
<?php } ?>
<?php if($node->field_host[0]['view']) { ?>
<h6 class="hosts">
Hosted by <?php $hostno = 0; foreach ($node->field_host as $one_host) { ?>
<?php if($hostno > 0) print "<span class='comma'>,</a>"; ?>
<span class="host"><?php print $one_host['view']; ?></span>
<?php $hostno++; } ?>
</h6>
<?php } ?>
<?php if(!empty($node->field_host_type[0]['view'])) { ?>
<h6 class="host-types">
<?php $hosttypesno = 0; foreach ($node->field_host_type as $one_host_type) { ?>
<?php if($hosttypesno > 0) print "<span class='comma'>,</a>"; ?>
<span class="host-type"><?php print $one_host_type['view']; ?></span>
<?php $hosttypesno++; } ?>
</h6>
<?php } ?>
</div> <!-- /.info -->
</div><!-- /.header -->
</div> <!-- left-column -->
<?php if($node->type != "news") { ?>
<?php if($node->field_image[0]['view']) { ?>
<div class="right-column">
<div class="header-image">
<div class="image"><?php print $node->field_image[0]['view']; ?> </div>
<div class="image-description"><?php print $node->field_image[0]['data']['description']; ?> </div>
</div><!-- /.header-image -->
</div><!-- /.right-column -->
<div class="left-column" id="node-content">
<?php } else { ?>
<div class="single-column" id="node-content">
<?php } ?>
<?php } ?>
<!--<div class="left-column" id="node-content">-->
<?php if ($node->taxonomy[13701]) { ?>
<?php if($node->field_media_embed[0]['view']) { ?>
<div class="video"><?php print $node->field_media_embed[0]['view']; ?></div>
<?php } ?>
<?php } ?>
<?php if($node->type == "series") { ?>
<?php print views_embed_view('also_in_this_series', 'series_listen', $node->nid); ?>
<!-- <div class="plus-button"><?php // print $_COOKIE["air-playlist"]; ?></div>-->
<?php } ?>
<?php if($node->type != "news") { ?>
<div class="share listen">
<?php if($node->field_audio_path[0]['safe']) { ?>
<div class="play">
<div class="listen-button">
<a href="<?php print $listen_url; ?>" onclick="popUpAIR(this.href,'fixed', 440, 570); return false;" target="<API key>"><img src="<?php print $base_url; ?>/sites/all/themes/artonair/images/triangle-white.png"></a>
</div>
<div class="listen-text"><a href="<?php print $listen_url; ?>" onclick="popUpAIR(this.href,'fixed', 440, 570); return false;" target="<API key>">Listen</a>
</div> <!-- /.listen-button -->
</div><!-- /.listen -->
<div class="plus-button"><?php print $_COOKIE["air-playlist"]; ?></div>
<?php } ?>
<div class="social">
<div class="addthis_toolbox <API key> facebook"><a class="<API key>" fb:like:layout="button_count"></a></div>
<script type="text/javascript" src="//s7.addthis.com/js/300/addthis_widget.js#pubid=xa-520a6a3258c56e49"></script>
<div class="twitter">
<a href="https://twitter.com/share" class="<TwitterConsumerkey>" data-via="clocktower_nyc">Tweet</a>
<script>!function(d,s,id){var js,fjs=d.<API key>(s)[0],p=/^http:/.test(d.location)?'http':'https';if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+'://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js,fjs);}}(document, 'script', 'twitter-wjs');</script>
</div><!-- /.twitter -->
</div> <!-- /.social -->
</div><!-- /.share .listen -->
<div class="content">
<?php print $node->content['body']['#value']; ?>
<?php if($node-><API key>[0]['view']) { ?>
<?php print $node-><API key>[0]['view']; ?>
<?php } ?>
<div class="content-foot">
<?php if($node->field_support[0]['view']) { ?>
<em><?php print $node->field_support[0]['view']; ?></em>
<?php } ?>
<?php if($node->type == "blog") { ?>
<h6 class="dates">Posted <?php print format_date($created, 'custom', 'F d, Y')?></h6>
<?php } ?>
<?php if($node->type == "show") { ?>
<?php if($node->field_aired_date[0]['view']) { ?>
<h6 class="aired_date">Originally aired <span class="aired_date_itself"><?php print $node->field_aired_date[0]['view']; ?></span></h6>
<?php } ?>
<div class="tags">
<h6 class="category"><?php print views_embed_view("radio_categories", "radio_tags", $node->nid); ?></h6>
</div>
<?php } ?>
<?php if($node->type == "series") { ?>
<h6 class="aired_date"><?php print views_embed_view('also_in_this_series', 'series_updated', $node->nid); ?></h6>
<div class="tags">
<h6 class="category"><?php print views_embed_view("radio_categories", "radio_tags", $node->nid); ?></h6>
</div>
<?php } ?>
<?php } ?>
<?php if($node->type == "blog") { ?>
<div class="tags">
<h6 class="category"><?php print views_embed_view("radio_categories", "radio_tags", $node->nid); ?></h6>
</div>
<?php } ?>
</div><!-- /.content-foot -->
</div><!-- /.content -->
</div><!-- /.left-column -->
<div class="right-column">
<div class="image-gallery">
<?php if($node->field_image[12]['view']) { ?>
<div class="thumbnails three">
<?php print views_embed_view('<API key>', 'default', $node->nid); ?>
</div>
<?php
} else { ?>
<?php if($node->field_image[1]['view']) { ?>
<div class="thumbnails">
<?php print views_embed_view('<API key>', 'default', $node->nid); ?>
</div>
<?php } ?>
<?php } ?>
</div><!-- /.image-gallery -->
</div><!-- /.right-column -->
</div><!-- /.bodyview -->
<?php if($node->type == "news") { ?>
<div class="in_this_news masonry">
<div class="news-body">
<?php print views_embed_view("new_this_week", "front_news_text", $node->nid); ?>
</div>
<div class="featured_projects" style="display:none;visibility:hidden;">
<?php print views_embed_view("in_this_news", "default", $node->nid); ?>
</div>
<div class="featured_radio" style="display:none;visibility:hidden;">
<?php print views_embed_view("in_this_news", "featured_radio", $node->nid); ?>
</div>
<div class="soundcloud item">
<?php $block = (object) module_invoke('block', 'block', 'view', "60");
print theme('block',$block); ?>
</div>
<div class="subscribe item">
<?php $block = (object) module_invoke('block', 'block', 'view', "42");
print theme('block',$block); ?>
</div>
</div><!-- /.in-this-news -->
<?php } ?>
<?php if($node->type != "news") { ?>
<?php $tags_display = views_embed_view('tags_for_node', 'default', $node->nid); ?>
<?php } ?>
<?php if($node->type == "blog") { ?>
<div class="also-list related">
<?php print views_embed_view('<API key>', 'related_to_event', $node->nid); ?>
</div> <!-- also-list -->
<?php } ?>
<?php if($node->type == "show" && $node->field_series[0]['view']) { ?>
<div class="also-list masonry">
<div class="title item">
<h6>Other Episodes From</h6>
<h1><?php print $node->field_series[0]['view']; ?></h1>
</div>
<div class="series-contents">
<?php print views_embed_view('also_in_this_series', 'grid_related_shows', $node->field_series[0]['nid'], $node->nid); ?>
</div>
</div><!-- also-list -->
<div class="also-list">
<div class="block block-staffpicks">
<?php
$view = views_get_view('staffpicks');
print $view->preview('block_2');
?>
</div><!-- block-staffpicks -->
<div class="block block-popular">
<?php
$view = views_get_view('most_viewed_sidebar');
print $view->preview('block_2');
?>
</div><!-- block-popular -->
</div><!-- also-list -->
<?php } ?>
<?php if($node->type == "series") { ?>
<div class="also-list masonry">
<div class="series-contents">
<?php print views_embed_view('series_contents', 'grid_related_shows', $node->nid); ?>
</div>
</div><!-- also-list -->
<?php } ?>
<?php if($node->type == "host") { ?>
<div class="also-list masonry">
<div class="title item"><h1>Radio Featuring <?php print $node->title; ?></h1></div>
<div class="by-this-host-browse smallgrid listview <API key>"> <!-- the gridlist choice applies to this div -->
<?php print views_embed_view('by_this_host', 'of_this_host', $node->nid); ?>
<?php print views_embed_view('by_this_host', 'block_2', $node->nid); ?>
</div>
</div>
<?php } ?>
</div>
<!-- for addthis analytics -->
<div id="nid-for-javascript" style="display:none;"><?php print $node->nid; ?></div>
|
<?php get_header(); ?>
<div id="content" class="clearfix">
<div id="main" class="col620 clearfix" role="main">
<article id="post-0" class="post error404 not-found">
<header class="entry-header">
<h1 class="entry-title"><?php _e( 'Error 404 - Page Not Found', 'newschannel' ); ?></h1>
</header>
<div class="entry-content post_content">
<h4><?php _e( 'It seems we can’t find what you’re looking for. Perhaps searching, or one of the links below, can help.', 'newschannel' ); ?></h4>
<div style="margin-bottom: 25px"><?php get_search_form(); ?></div>
<?php the_widget( '<API key>' ); ?>
<div class="widget">
<h2 class="widgettitle"><?php _e( 'Most Used Categories', 'newschannel' ); ?></h2>
<ul>
<?php wp_list_categories( array( 'orderby' => 'count', 'order' => 'DESC', 'show_count' => 1, 'title_li' => '', 'number' => 10 ) ); ?>
</ul>
</div>
<?php
/* translators: %1$s: smilie */
$archive_content = '<p>' . sprintf( __( 'Try looking in the monthly archives. %1$s', 'newschannel' ), convert_smilies( ':)' ) ) . '</p>';
the_widget( 'WP_Widget_Archives', 'dropdown=1', "after_title=</h2>$archive_content" );
?>
<?php the_widget( 'WP_Widget_Tag_Cloud' ); ?>
</div><!-- .entry-content -->
</article><!-- #post-0 -->
</div> <!-- end #main -->
<?php get_sidebar(); ?>
</div> <!-- end #content -->
<?php get_footer(); ?>
|
package scatterbox.utils;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.<API key>;
import java.io.InputStreamReader;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Timestamp;
import java.util.HashMap;
import org.joda.time.DateTime;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;
public class ImportVanKasteren {
String dataFileName = "/Users/knoxs/Documents/datasets/kasterenDataset/kasterenSenseData.txt";
String annotationFileName = "/Users/knoxs/Documents/datasets/kasterenDataset/kasterenActData.txt";
File dataFile = new File(dataFileName);
File annotationFile = new File(annotationFileName);
BufferedReader dataFileReader;
BufferedReader <API key>;
Connection conn = null;
String insertDataCommand = "insert into events (start_time, end_time, id, java_type) values (\"START\", \"END\", \"OBJECT\", \"scatterbox.event.KasterenEvent\")";
String <API key> = "insert into annotations (start_time, end_time, annotation) values (\"START\", \"END\", \"ANNOTATION\")";
HashMap<Integer, String> objects = new HashMap<Integer, String>();
HashMap<Integer, String> annotations = new HashMap<Integer, String>();
//String[] annotations = {"leavehouse", "usetoilet", "takeshower", "gotobed", "preparebreakfast", "preparedinner", "getdrink"};
/**
* Format of the sql timestamp. Allows easy conversion to date format
*/
final DateTimeFormatter dateTimeFormatter = DateTimeFormat
.forPattern("dd-MMM-yyyy HH:mm:ss");
public static void main(String[] args) throws <API key> {
ImportVanKasteren ivk = new ImportVanKasteren();
ivk.connectToDatabase();
ivk.dataFileReader = new BufferedReader(new InputStreamReader(
new DataInputStream(new FileInputStream(ivk.dataFileName))));
ivk.<API key> = new BufferedReader(new InputStreamReader(
new DataInputStream(new FileInputStream(ivk.annotationFileName))));
ivk.setUpAnnotations();
ivk.setUpObjects();
ivk.getData();
ivk.getAnnotations();
}
private void getData() {
String line;
try {
while ((line = dataFileReader.readLine()) != null) {
String[] readingArray = line.split("\t");
DateTime startTime = dateTimeFormatter
.parseDateTime(readingArray[0]);
Timestamp startTimestamp = new Timestamp(startTime.getMillis());
DateTime endTime = dateTimeFormatter.parseDateTime(readingArray[1]);
Timestamp endTimestamp = new Timestamp(endTime.getMillis());
int id = Integer.parseInt(readingArray[2]);
//The reason for -1 is because, kasteren starts id names at 1, not 0, but the array starts at 0.
String object = objects.get(id);
insertStatement(insertDataCommand.replace("START",
startTimestamp.toString()).replace("END",
endTimestamp.toString()).replace("OBJECT", object));
}
} catch (Exception ioe) {
ioe.printStackTrace();
}
}
private void getAnnotations() {
String line;
try {
while ((line = <API key>.readLine()) != null) {
String[] readingArray = line.split("\t");
DateTime startTime = dateTimeFormatter
.parseDateTime(readingArray[0]);
Timestamp startTimestamp = new Timestamp(startTime.getMillis());
DateTime endTime = dateTimeFormatter.parseDateTime(readingArray[1]);
Timestamp endTimestamp = new Timestamp(endTime.getMillis());
int id = Integer.parseInt(readingArray[2]);
//The reason for -1 is because, kasteren starts id names at 1, not 0, but the array starts at 0.
String annotation = annotations.get(id);
insertStatement(<API key>.replace("START",
startTimestamp.toString()).replace("END",
endTimestamp.toString()).replace("ANNOTATION", annotation));
}
} catch (Exception ioe) {
ioe.printStackTrace();
}
}
public boolean insertStatement(String an_sql_statement) {
System.out.println(an_sql_statement);
boolean success = false;
//System.out.println(an_sql_statement);
Statement statement;
try {
statement = conn.createStatement();
if (conn != null) {
success = statement.execute(an_sql_statement);
statement.close();
} else {
System.err.println("No database connection!!!");
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return success;
}
public boolean connectToDatabase() {
boolean connected = false;
String userName = "root";
String password = "";
String url = "jdbc:mysql://localhost:3306/tvk";
try {
Class.forName("com.mysql.jdbc.Driver").newInstance();
conn = DriverManager.getConnection(url, userName, password);
if (conn != null) {
connected = true;
}
} catch (<API key> e) {
e.printStackTrace();
} catch (<API key> e) {
e.printStackTrace();
} catch (<API key> e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
return connected;
}
private void setUpObjects() {
objects.put(1, "microwave");
objects.put(5, "halltoiletdoor");
objects.put(6, "hallbathroomdoor");
objects.put(7, "cupscupboard");
objects.put(8, "fridge");
objects.put(9, "platescupboard");
objects.put(12, "frontdoor");
objects.put(13, "dishwasher");
objects.put(14, "toiletflush");
objects.put(17, "freezer");
objects.put(18, "panscupboard");
objects.put(20, "washingmachine");
objects.put(23, "groceriescupboard");
objects.put(24, "hallbedroomdoor");
}
private void setUpAnnotations() {
annotations.put(1, "leavehouse");
annotations.put(4, "usetoilet");
annotations.put(5, "takeshower");
annotations.put(10, "gotobed");
annotations.put(13, "preparebreakfast");
annotations.put(15, "preparedinner");
annotations.put(17, "getdrink");
}
}
|
<?php
defined('_JEXEC') or die;
// Include the component HTML helpers.
JHtml::addIncludePath(JPATH_COMPONENT . '/helpers/html');
JHtml::_('bootstrap.tooltip');
JHtml::_('behavior.formvalidator');
JHtml::_('behavior.keepalive');
JHtml::_('behavior.tabstate');
$input = JFactory::getApplication()->input;
// No access if not global SuperUser
if (!JFactory::getUser()->authorise('core.admin'))
{
JFactory::getApplication()->enqueueMessage(JText::_('<API key>'), 'danger');
}
if ($this->type == 'image')
{
JHtml::_('script', 'vendor/cropperjs/cropper.min.js', array('version' => 'auto', 'relative' => true));
JHtml::_('stylesheet', 'vendor/cropperjs/cropper.min.css', array('version' => 'auto', 'relative' => true));
}
JFactory::getDocument()-><API key>("
jQuery(document).ready(function($){
// Hide all the folder when the page loads
$('.folder ul, .component-folder ul').hide();
// Display the tree after loading
$('.directory-tree').removeClass('directory-tree');
// Show all the lists in the path of an open file
$('.show > ul').show();
// Stop the default action of anchor tag on a click event
$('.folder-url, .<API key>').click(function(event){
event.preventDefault();
});
// Prevent the click event from proliferating
$('.file, .component-file-url').bind('click',function(e){
e.stopPropagation();
});
// Toggle the child indented list on a click event
$('.folder, .component-folder').bind('click',function(e){
$(this).children('ul').toggle();
e.stopPropagation();
});
// New file tree
$('#fileModal .folder-url').bind('click',function(e){
$('.folder-url').removeClass('selected');
e.stopPropagation();
$('#fileModal input.address').val($(this).attr('data-id'));
$(this).addClass('selected');
});
// Folder manager tree
$('#folderModal .folder-url').bind('click',function(e){
$('.folder-url').removeClass('selected');
e.stopPropagation();
$('#folderModal input.address').val($(this).attr('data-id'));
$(this).addClass('selected');
});
var containerDiv = document.querySelector('.span3.tree-holder'),
treeContainer = containerDiv.querySelector('.nav.nav-list'),
liEls = treeContainer.querySelectorAll('.folder.show'),
filePathEl = document.querySelector('p.lead.hidden.path');
if(filePathEl)
var filePathTmp = document.querySelector('p.lead.hidden.path').innerText;
if(filePathTmp && filePathTmp.charAt( 0 ) === '/' ) {
filePathTmp = filePathTmp.slice( 1 );
filePathTmp = filePathTmp.split('/');
filePathTmp = filePathTmp[filePathTmp.length - 1];
var re = new RegExp( filePathTmp );
for (var i = 0, l = liEls.length; i < l; i++) {
liEls[i].querySelector('a').classList.add('active');
if (i === liEls.length - 1) {
var parentUl = liEls[i].querySelector('ul'),
allLi = parentUl.querySelectorAll('li');
for (var i = 0, l = allLi.length; i < l; i++) {
aEl = allLi[i].querySelector('a'),
spanEl = aEl.querySelector('span');
if (spanEl && re.test(spanEl.innerText)) {
aEl.classList.add('active');
}
}
}
}
}
});");
if ($this->type == 'image')
{
JFactory::getDocument()-><API key>("
document.addEventListener('DOMContentLoaded', function() {
// Configuration for image cropping
var image = document.getElementById('image-crop');
var cropper = new Cropper(image, {
viewMode: 0,
scalable: true,
zoomable: true,
minCanvasWidth: " . $this->image['width'] . ",
minCanvasHeight: " . $this->image['height'] . ",
});
image.addEventListener('crop', function (e) {
document.getElementById('x').value = e.detail.x;
document.getElementById('y').value = e.detail.y;
document.getElementById('w').value = e.detail.width;
document.getElementById('h').value = e.detail.height;
});
// Function for clearing the coordinates
function clearCoords()
{
var inputs = querySelectorAll('#adminForm input');
for(i=0, l=inputs.length; l>i; i++) {
inputs[i].value = '';
};
}
});");
}
JFactory::getDocument()->addStyleDeclaration('
/* Styles for modals */
.selected {
background: #08c;
color: #fff;
}
.selected:hover {
background: #08c !important;
color: #fff;
}
.modal-body .column-left {
float: left; max-height: 70vh; overflow-y: auto;
}
.modal-body .column-right {
float: right;
}
@media (max-width: 767px) {
.modal-body .column-right {
float: left;
}
}
#deleteFolder {
margin: 0;
}
#image-crop {
max-width: 100% !important;
width: auto;
height: auto;
}
.directory-tree {
display: none;
}
.tree-holder {
overflow-x: auto;
}
');
if ($this->type == 'font')
{
JFactory::getDocument()->addStyleDeclaration(
"/* Styles for font preview */
@font-face
{
font-family: previewFont;
src: url('" . $this->font['address'] . "')
}
.font-preview{
font-family: previewFont !important;
}"
);
}
?>
<?php echo JHtml::_('bootstrap.startTabSet', 'myTab', array('active' => 'editor')); ?>
<?php echo JHtml::_('bootstrap.addTab', 'myTab', 'editor', JText::_('<API key>')); ?>
<div class="row">
<div class="col-md-12">
<?php if($this->type == 'file') : ?>
<p class="lead"><?php echo JText::sprintf('<API key>', $this->source->filename, $this->template->element); ?></p>
<p class="lead path hidden"><?php echo $this->source->filename; ?></p>
<?php endif; ?>
<?php if($this->type == 'image') : ?>
<p class="lead"><?php echo JText::sprintf('<API key>', $this->image['path'], $this->template->element); ?></p>
<p class="lead path hidden"><?php echo $this->image['path']; ?></p>
<?php endif; ?>
<?php if($this->type == 'font') : ?>
<p class="lead"><?php echo JText::sprintf('<API key>', $this->font['rel_path'], $this->template->element); ?></p>
<p class="lead path hidden"><?php echo $this->font['rel_path']; ?></p>
<?php endif; ?>
</div>
</div>
<div class="row">
<div class="col-md-3 tree-holder">
<?php echo $this->loadTemplate('tree'); ?>
</div>
<div class="col-md-9">
<?php if ($this->type == 'home') : ?>
<form action="<?php echo JRoute::_('index.php?option=com_templates&view=template&id=' . $input->getInt('id') . '&file=' . $this->file); ?>" method="post" name="adminForm" id="adminForm">
<input type="hidden" name="task" value="">
<?php echo JHtml::_('form.token'); ?>
<h2><?php echo JText::_('<API key>'); ?></h2>
<p><?php echo JText::_('<API key>'); ?></p>
<p>
<a href="https://docs.joomla.org/J3.x:<API key>" target="_blank" class="btn btn-primary btn-lg">
<?php echo JText::_('<API key>'); ?>
</a>
</p>
</form>
<?php endif; ?>
<?php if ($this->type == 'file') : ?>
<form action="<?php echo JRoute::_('index.php?option=com_templates&view=template&id=' . $input->getInt('id') . '&file=' . $this->file); ?>" method="post" name="adminForm" id="adminForm">
<div class="editor-border">
<?php echo $this->form->getInput('source'); ?>
</div>
<input type="hidden" name="task" value="" />
<?php echo JHtml::_('form.token'); ?>
<?php echo $this->form->getInput('extension_id'); ?>
<?php echo $this->form->getInput('filename'); ?>
</form>
<?php endif; ?>
<?php if ($this->type == 'archive') : ?>
<legend><?php echo JText::_('<API key>'); ?></legend>
<form action="<?php echo JRoute::_('index.php?option=com_templates&view=template&id=' . $input->getInt('id') . '&file=' . $this->file); ?>" method="post" name="adminForm" id="adminForm">
<ul class="nav flex-column well">
<?php foreach ($this->archive as $file) : ?>
<li>
<?php if (substr($file, -1) === DIRECTORY_SEPARATOR) : ?>
<i class="fa-fw fa fa-folder"></i> <?php echo $file; ?>
<?php endif; ?>
<?php if (substr($file, -1) != DIRECTORY_SEPARATOR) : ?>
<i class="fa-fw fa fa-file-o"></i> <?php echo $file; ?>
<?php endif; ?>
</li>
<?php endforeach; ?>
</ul>
<input type="hidden" name="task" value="">
<?php echo JHtml::_('form.token'); ?>
</form>
<?php endif; ?>
<?php if ($this->type == 'image') : ?>
<img id="image-crop" src="<?php echo $this->image['address'] . '?' . time(); ?>">
<form action="<?php echo JRoute::_('index.php?option=com_templates&view=template&id=' . $input->getInt('id') . '&file=' . $this->file); ?>" method="post" name="adminForm" id="adminForm">
<fieldset class="adminform">
<input type ="hidden" id="x" name="x">
<input type ="hidden" id="y" name="y">
<input type ="hidden" id="h" name="h">
<input type ="hidden" id="w" name="w">
<input type="hidden" name="task" value="">
<?php echo JHtml::_('form.token'); ?>
</fieldset>
</form>
<?php endif; ?>
<?php if ($this->type == 'font') : ?>
<div class="font-preview">
<form action="<?php echo JRoute::_('index.php?option=com_templates&view=template&id=' . $input->getInt('id') . '&file=' . $this->file); ?>" method="post" name="adminForm" id="adminForm">
<fieldset class="adminform">
<h1>H1. Quickly gaze at Joomla! views from HTML, CSS, JavaScript and XML</h1>
<h2>H2. Quickly gaze at Joomla! views from HTML, CSS, JavaScript and XML</h2>
<h3>H3. Quickly gaze at Joomla! views from HTML, CSS, JavaScript and XML</h3>
<h4>H4. Quickly gaze at Joomla! views from HTML, CSS, JavaScript and XML</h4>
<h5>H5. Quickly gaze at Joomla! views from HTML, CSS, JavaScript and XML</h5>
<h6>H6. Quickly gaze at Joomla! views from HTML, CSS, JavaScript and XML</h6>
<p><b>Bold. Quickly gaze at Joomla! views from HTML, CSS, JavaScript and XML</b></p>
<p><i>Italics. Quickly gaze at Joomla! views from HTML, CSS, JavaScript and XML</i></p>
<p>Unordered List</p>
<ul>
<li>Item</li>
<li>Item</li>
<li>Item<br>
<ul>
<li>Item</li>
<li>Item</li>
<li>Item<br>
<ul>
<li>Item</li>
<li>Item</li>
<li>Item</li>
</ul>
</li>
</ul>
</li>
</ul>
<p class="lead">Ordered List</p>
<ol>
<li>Item</li>
<li>Item</li>
<li>Item<br>
<ul>
<li>Item</li>
<li>Item</li>
<li>Item<br>
<ul>
<li>Item</li>
<li>Item</li>
<li>Item</li>
</ul>
</li>
</ul>
</li>
</ol>
<input type="hidden" name="task" value="">
<?php echo JHtml::_('form.token'); ?>
</fieldset>
</form>
</div>
<?php endif; ?>
</div>
</div>
<?php echo JHtml::_('bootstrap.endTab'); ?>
<?php echo JHtml::_('bootstrap.addTab', 'myTab', 'overrides', JText::_('<API key>')); ?>
<div class="row">
<div class="col-md-4">
<legend><?php echo JText::_('<API key>'); ?></legend>
<ul class="list-unstyled">
<?php $token = JSession::getFormToken() . '=' . 1; ?>
<?php foreach ($this->overridesList['modules'] as $module) : ?>
<li>
<?php
$overrideLinkUrl = 'index.php?option=com_templates&view=template&task=template.overrides&folder=' . $module->path
. '&id=' . $input->getInt('id') . '&file=' . $this->file . '&' . $token;
?>
<a href="<?php echo JRoute::_($overrideLinkUrl); ?>">
<i class="fa fa-files-o"></i> <?php echo $module->name; ?>
</a>
</li>
<?php endforeach; ?>
</ul>
</div>
<div class="col-md-4">
<legend><?php echo JText::_('<API key>'); ?></legend>
<ul class="list-unstyled">
<?php $token = JSession::getFormToken() . '=' . 1; ?>
<?php foreach ($this->overridesList['components'] as $key => $value) : ?>
<li class="component-folder">
<a href="#" class="<API key>">
<i class="fa fa-folder"></i> <?php echo $key; ?>
</a>
<ul class="list-unstyled">
<?php foreach ($value as $view) : ?>
<li>
<?php
$overrideLinkUrl = 'index.php?option=com_templates&view=template&task=template.overrides&folder=' . $view->path
. '&id=' . $input->getInt('id') . '&file=' . $this->file . '&' . $token;
?>
<a class="component-file-url" href="<?php echo JRoute::_($overrideLinkUrl); ?>">
<i class="fa fa-files-o"></i> <?php echo $view->name; ?>
</a>
</li>
<?php endforeach; ?>
</ul>
</li>
<?php endforeach; ?>
</ul>
</div>
<div class="col-md-4">
<legend><?php echo JText::_('<API key>'); ?></legend>
<ul class="nav flex-column">
<?php $token = JSession::getFormToken() . '=' . 1; ?>
<?php foreach ($this->overridesList['layouts'] as $layout) : ?>
<li>
<?php
$overrideLinkUrl = 'index.php?option=com_templates&view=template&task=template.overrides&folder=' . $layout->path
. '&id=' . $input->getInt('id') . '&file=' . $this->file . '&' . $token;
?>
<a href="<?php echo JRoute::_($overrideLinkUrl); ?>">
<i class="fa fa-files-o"></i> <?php echo $layout->name; ?>
</a>
</li>
<?php endforeach; ?>
</ul>
</div>
</div>
<?php echo JHtml::_('bootstrap.endTab'); ?>
<?php echo JHtml::_('bootstrap.addTab', 'myTab', 'description', JText::_('<API key>')); ?>
<?php echo $this->loadTemplate('description'); ?>
<?php echo JHtml::_('bootstrap.endTab'); ?>
<?php echo JHtml::_('bootstrap.endTabSet'); ?>
<?php // Collapse Modal
$copyModalData = array(
'selector' => 'copyModal',
'params' => array(
'title' => JText::_('<API key>'),
'footer' => $this->loadTemplate('modal_copy_footer')
),
'body' => $this->loadTemplate('modal_copy_body')
);
?>
<form action="<?php echo JRoute::_('index.php?option=com_templates&task=template.copy&id=' . $input->getInt('id') . '&file=' . $this->file); ?>" method="post" name="adminForm" id="adminForm">
<?php echo JLayoutHelper::render('joomla.modal.main', $copyModalData); ?>
<?php echo JHtml::_('form.token'); ?>
</form>
<?php if ($this->type != 'home') : ?>
<?php // Rename Modal
$renameModalData = array(
'selector' => 'renameModal',
'params' => array(
'title' => JText::sprintf('<API key>', $this->fileName),
'footer' => $this->loadTemplate('modal_rename_footer')
),
'body' => $this->loadTemplate('modal_rename_body')
);
?>
<form action="<?php echo JRoute::_('index.php?option=com_templates&task=template.renameFile&id=' . $input->getInt('id') . '&file=' . $this->file); ?>" method="post">
<?php echo JLayoutHelper::render('joomla.modal.main', $renameModalData); ?>
<?php echo JHtml::_('form.token'); ?>
</form>
<?php endif; ?>
<?php if ($this->type != 'home') : ?>
<?php // Delete Modal
$deleteModalData = array(
'selector' => 'deleteModal',
'params' => array(
'title' => JText::_('<API key>'),
'footer' => $this->loadTemplate('modal_delete_footer')
),
'body' => $this->loadTemplate('modal_delete_body')
);
?>
<?php echo JLayoutHelper::render('joomla.modal.main', $deleteModalData); ?>
<?php endif; ?>
<?php // File Modal
$fileModalData = array(
'selector' => 'fileModal',
'params' => array(
'title' => JText::_('<API key>'),
'footer' => $this->loadTemplate('modal_file_footer')
),
'body' => $this->loadTemplate('modal_file_body')
);
?>
<?php echo JLayoutHelper::render('joomla.modal.main', $fileModalData); ?>
<?php // Folder Modal
$folderModalData = array(
'selector' => 'folderModal',
'params' => array(
'title' => JText::_('<API key>'),
'footer' => $this->loadTemplate('modal_folder_footer')
),
'body' => $this->loadTemplate('modal_folder_body')
);
?>
<?php echo JLayoutHelper::render('joomla.modal.main', $folderModalData); ?>
<?php if ($this->type != 'home') : ?>
<?php // Resize Modal
$resizeModalData = array(
'selector' => 'resizeModal',
'params' => array(
'title' => JText::_('<API key>'),
'footer' => $this->loadTemplate('modal_resize_footer')
),
'body' => $this->loadTemplate('modal_resize_body')
);
?>
<form action="<?php echo JRoute::_('index.php?option=com_templates&task=template.resizeImage&id=' . $input->getInt('id') . '&file=' . $this->file); ?>" method="post">
<?php echo JLayoutHelper::render('joomla.modal.main', $resizeModalData); ?>
<?php echo JHtml::_('form.token'); ?>
</form>
<?php endif; ?>
|
<!
from emacs.texi on 3 March 1994
<TITLE>GNU Emacs Manual - Commands for Human Languages</TITLE>
<P>Go to the <A HREF="emacs_24.html">previous</A>, <A HREF="emacs_26.html">next</A> section.<P>
<A NAME="IDX723"></A>
<A NAME="IDX724"></A>
<H1><A NAME="SEC155" HREF="emacs_toc.html#SEC155">Commands for Human Languages</A></H1>
<P>
The term <DFN>text</DFN> has two widespread meanings in our area of the
computer field. One is data that is a sequence of characters. Any file
that you edit with Emacs is text, in this sense of the word. The other
meaning is more restrictive: a sequence of characters in a human language
for humans to read (possibly after processing by a text formatter), as
opposed to a program or commands for a program.
<P>
Human languages have syntactic/stylistic conventions that can be
supported or used to advantage by editor commands: conventions involving
words, sentences, paragraphs, and capital letters. This chapter
describes Emacs commands for all of these things. There are also
commands for <DFN>filling</DFN>, which means rearranging the lines of a
paragraph to be approximately equal in length. The commands for moving
over and killing words, sentences and paragraphs, while intended
primarily for editing text, are also often useful for editing programs.
<P>
Emacs has several major modes for editing human language text.
If the file contains text pure and simple, use Text mode, which customizes
Emacs in small ways for the syntactic conventions of text. For text which
contains embedded commands for text formatters, Emacs has other major modes,
each for a particular text formatter. Thus, for input to TeX, you would
use TeX mode; for input to nroff, Nroff mode.
<P>
<A NAME="IDX725"></A>
<A NAME="IDX726"></A>
<H2><A NAME="SEC156" HREF="emacs_toc.html#SEC156">Words</A></H2>
<P>
Emacs has commands for moving over or operating on words. By convention,
the keys for them are all Meta characters.
<P>
<DL COMPACT>
<DT><KBD>M-f</KBD>
<DD>Move forward over a word (<CODE>forward-word</CODE>).
<DT><KBD>M-b</KBD>
<DD>Move backward over a word (<CODE>backward-word</CODE>).
<DT><KBD>M-d</KBD>
<DD>Kill up to the end of a word (<CODE>kill-word</CODE>).
<DT><KBD>M-<KBD>DEL</KBD></KBD>
<DD>Kill back to the beginning of a word (<CODE>backward-kill-word</CODE>).
<DT><KBD>M-@</KBD>
<DD>Mark the end of the next word (<CODE>mark-word</CODE>).
<DT><KBD>M-t</KBD>
<DD>Transpose two words or drag a word across other words
(<CODE>transpose-words</CODE>).
</DL>
<P>
Notice how these keys form a series that parallels the
character-based <KBD>C-f</KBD>, <KBD>C-b</KBD>, <KBD>C-d</KBD>, <KBD>C-t</KBD> and
<KBD>DEL</KBD>. <KBD>M-@</KBD> is related to <KBD>C-@</KBD>, which is an alias for
<KBD>C-<KBD>SPC</KBD></KBD>.<A NAME="IDX727"></A>
<A NAME="IDX728"></A>
<A NAME="IDX729"></A>
<A NAME="IDX730"></A>
<P>
The commands <KBD>M-f</KBD> (<CODE>forward-word</CODE>) and <KBD>M-b</KBD>
(<CODE>backward-word</CODE>) move forward and backward over words. These
Meta characters are thus analogous to the corresponding control
characters, <KBD>C-f</KBD> and <KBD>C-b</KBD>, which move over single characters
in the text. The analogy extends to numeric arguments, which serve as
repeat counts. <KBD>M-f</KBD> with a negative argument moves backward, and
<KBD>M-b</KBD> with a negative argument moves forward. Forward motion
stops right after the last letter of the word, while backward motion
stops right before the first letter.<A NAME="IDX731"></A>
<A NAME="IDX732"></A>
<P>
<KBD>M-d</KBD> (<CODE>kill-word</CODE>) kills the word after point. To be
precise, it kills everything from point to the place <KBD>M-f</KBD> would
move to. Thus, if point is in the middle of a word, <KBD>M-d</KBD> kills
just the part after point. If some punctuation comes between point and the
next word, it is killed along with the word. (If you wish to kill only the
next word but not the punctuation before it, simply do <KBD>M-f</KBD> to get
the end, and kill the word backwards with <KBD>M-<KBD>DEL</KBD></KBD>.)
<KBD>M-d</KBD> takes arguments just like <KBD>M-f</KBD>.
<A NAME="IDX733"></A>
<A NAME="IDX734"></A>
<P>
<KBD>M-<KBD>DEL</KBD></KBD> (<CODE>backward-kill-word</CODE>) kills the word before
point. It kills everything from point back to where <KBD>M-b</KBD> would
move to. If point is after the space in <SAMP>`FOO, BAR'</SAMP>, then
<SAMP>`FOO, '</SAMP> is killed. (If you wish to kill just <SAMP>`FOO'</SAMP>, do
<KBD>M-b M-d</KBD> instead of <KBD>M-<KBD>DEL</KBD></KBD>.)
<A NAME="IDX735"></A>
<A NAME="IDX736"></A>
<P>
<KBD>M-t</KBD> (<CODE>transpose-words</CODE>) exchanges the word before or
containing point with the following word. The delimiter characters between
the words do not move. For example, <SAMP>`FOO, BAR'</SAMP> transposes into
<SAMP>`BAR, FOO'</SAMP> rather than <SAMP>`BAR FOO,'</SAMP>. See section <A HREF="emacs_18.html#SEC93">Transposing Text</A>, for
more on transposition and on arguments to transposition commands.
<A NAME="IDX737"></A>
<A NAME="IDX738"></A>
<P>
To operate on the next <VAR>n</VAR> words with an operation which applies
between point and mark, you can either set the mark at point and then move
over the words, or you can use the command <KBD>M-@</KBD> (<CODE>mark-word</CODE>)
which does not move point, but sets the mark where <KBD>M-f</KBD> would move
to. <KBD>M-@</KBD> accepts a numeric argument that says how many words to
scan for the place to put the mark.
<P>
The word commands' understanding of syntax is completely controlled by
the syntax table. Any character can, for example, be declared to be a word
delimiter. See section <A HREF="emacs_35.html#SEC355">The Syntax Table</A>.
<P>
<A NAME="IDX739"></A>
<A NAME="IDX740"></A>
<H2><A NAME="SEC157" HREF="emacs_toc.html#SEC157">Sentences</A></H2>
<P>
The Emacs commands for manipulating sentences and paragraphs are mostly
on Meta keys, so as to be like the word-handling commands.
<P>
<DL COMPACT>
<DT><KBD>M-a</KBD>
<DD>Move back to the beginning of the sentence (<CODE>backward-sentence</CODE>).
<DT><KBD>M-e</KBD>
<DD>Move forward to the end of the sentence (<CODE>forward-sentence</CODE>).
<DT><KBD>M-k</KBD>
<DD>Kill forward to the end of the sentence (<CODE>kill-sentence</CODE>).
<DT><KBD>C-x <KBD>DEL</KBD></KBD>
<DD>Kill back to the beginning of the sentence (<CODE><API key></CODE>).
</DL>
<A NAME="IDX741"></A>
<A NAME="IDX742"></A>
<A NAME="IDX743"></A>
<A NAME="IDX744"></A>
<P>
The commands <KBD>M-a</KBD> and <KBD>M-e</KBD> (<CODE>backward-sentence</CODE> and
<CODE>forward-sentence</CODE>) move to the beginning and end of the current
sentence, respectively. They were chosen to resemble <KBD>C-a</KBD> and
<KBD>C-e</KBD>, which move to the beginning and end of a line. Unlike them,
<KBD>M-a</KBD> and <KBD>M-e</KBD> if repeated or given numeric arguments move over
successive sentences. Emacs assumes that the typist's convention is
followed, and thus considers a sentence to end wherever there is a
<SAMP>`.'</SAMP>, <SAMP>`?'</SAMP> or <SAMP>`!'</SAMP> followed by the end of a line or two spaces,
with any number of <SAMP>`)'</SAMP>, <SAMP>`]'</SAMP>, <SAMP>`''</SAMP>, or <SAMP>`"'</SAMP> characters
allowed in between. A sentence also begins or ends wherever a paragraph
begins or ends.<P>
Neither <KBD>M-a</KBD> nor <KBD>M-e</KBD> moves past the newline or spaces beyond
the sentence edge at which it is stopping.
<A NAME="IDX745"></A>
<A NAME="IDX746"></A>
<A NAME="IDX747"></A>
<A NAME="IDX748"></A>
<P>
Just as <KBD>C-a</KBD> and <KBD>C-e</KBD> have a kill command, <KBD>C-k</KBD>, to go
with them, so <KBD>M-a</KBD> and <KBD>M-e</KBD> have a corresponding kill command
<KBD>M-k</KBD> (<CODE>kill-sentence</CODE>) which kills from point to the end of the
sentence. With minus one as an argument it kills back to the beginning of
the sentence. Larger arguments serve as a repeat count.<P>
There is a special command, <KBD>C-x <KBD>DEL</KBD></KBD>
(<CODE><API key></CODE>) for killing back to the beginning of a
sentence, because this is useful when you change your mind in the middle of
composing text.<A NAME="IDX749"></A>
<P>
The variable <CODE>sentence-end</CODE> controls recognition of the end of a
sentence. It is a regexp that matches the last few characters of a
sentence, together with the whitespace following the sentence. Its
normal value is
<P>
<PRE>
"[.?!][]\"')]*\\($\\|\t\\| \\)[ \t\n]*"
</PRE>
<P>
This example is explained in the section on regexps. See section <A HREF="emacs_17.html#SEC83">Syntax of Regular Expressions</A>.
<P>
<A NAME="IDX750"></A>
<A NAME="IDX751"></A>
<A NAME="IDX752"></A>
<A NAME="IDX753"></A>
<A NAME="IDX754"></A>
<A NAME="IDX755"></A>
<H2><A NAME="SEC158" HREF="emacs_toc.html#SEC158">Paragraphs</A></H2>
<P>
The Emacs commands for manipulating paragraphs are also Meta keys.
<P>
<DL COMPACT>
<DT><KBD>M-{</KBD>
<DD>Move back to previous paragraph beginning (<CODE>backward-paragraph</CODE>).
<DT><KBD>M-}</KBD>
<DD>Move forward to next paragraph end (<CODE>forward-paragraph</CODE>).
<DT><KBD>M-h</KBD>
<DD>Put point and mark around this or next paragraph (<CODE>mark-paragraph</CODE>).
</DL>
<P>
<KBD>M-{</KBD> moves to the beginning of the current or previous paragraph,
while <KBD>M-}</KBD> moves to the end of the current or next paragraph.
Blank lines and text formatter command lines separate paragraphs and are
not part of any paragraph. Also, an indented line starts a new
paragraph.
<P>
In major modes for programs (as opposed to Text mode), paragraphs begin
and end only at blank lines. This makes the paragraph commands continue to
be useful even though there are no paragraphs per se.
<P>
When there is a fill prefix, then paragraphs are delimited by all lines
which don't start with the fill prefix. See section <A HREF="emacs_25.html#SEC160">Filling Text</A>.
<A NAME="IDX756"></A>
<A NAME="IDX757"></A>
<P>
When you wish to operate on a paragraph, you can use the command
<KBD>M-h</KBD> (<CODE>mark-paragraph</CODE>) to set the region around it. This
command puts point at the beginning and mark at the end of the paragraph
point was in. If point is between paragraphs (in a run of blank lines, or
at a boundary), the paragraph following point is surrounded by point and
mark. If there are blank lines preceding the first line of the paragraph,
one of these blank lines is included in the region. Thus, for example,
<KBD>M-h C-w</KBD> kills the paragraph around or after point.
<A NAME="IDX758"></A>
<A NAME="IDX759"></A>
<P>
The precise definition of a paragraph boundary is controlled by the
variables <CODE>paragraph-separate</CODE> and <CODE>paragraph-start</CODE>. The
value of <CODE>paragraph-start</CODE> is a regexp that should match any line
that either starts or separates paragraphs. The value of
<CODE>paragraph-separate</CODE> is another regexp that should match only lines
that separate paragraphs without being part of any paragraph. Lines
that start a new paragraph and are contained in it must match only
<CODE>paragraph-start</CODE>, not <CODE>paragraph-separate</CODE>. For example,
normally <CODE>paragraph-start</CODE> is <CODE>"^[ <TT>\</TT>t<TT>\</TT>n<TT>\</TT>f]"</CODE> and
<CODE>paragraph-separate</CODE> is <CODE>"^[ <TT>\</TT>t<TT>\</TT>f]*$"</CODE>.<P>
Normally it is desirable for page boundaries to separate paragraphs.
The default values of these variables recognize the usual separator for
pages.
<P>
<H2><A NAME="SEC159" HREF="emacs_toc.html#SEC159">Pages</A></H2>
<A NAME="IDX760"></A>
<A NAME="IDX761"></A>
<P>
Files are often thought of as divided into <DFN>pages</DFN> by the
<DFN>formfeed</DFN> character (ASCII control-L, octal code 014). For example,
if a file is printed on a line printer, each page of the file, in this
sense, will start on a new page of paper. Emacs treats a page-separator
character just like any other character. You can insert it with <KBD>C-q
C-l</KBD>, or delete it with <KBD>DEL</KBD>. Thus, you are free to paginate your file
or not. However, since pages are often meaningful divisions of the file,
Emacs provides commands to move over them and operate on them.
<P>
<DL COMPACT>
<DT><KBD>C-x [</KBD>
<DD>Move point to previous page boundary (<CODE>backward-page</CODE>).
<DT><KBD>C-x ]</KBD>
<DD>Move point to next page boundary (<CODE>forward-page</CODE>).
<DT><KBD>C-x C-p</KBD>
<DD>Put point and mark around this page (or another page) (<CODE>mark-page</CODE>).
<DT><KBD>C-x l</KBD>
<DD>Count the lines in this page (<CODE>count-lines-page</CODE>).
</DL>
<A NAME="IDX762"></A>
<A NAME="IDX763"></A>
<A NAME="IDX764"></A>
<A NAME="IDX765"></A>
<P>
The <KBD>C-x [</KBD> (<CODE>backward-page</CODE>) command moves point to immediately
after the previous page delimiter. If point is already right after a page
delimiter, it skips that one and stops at the previous one. A numeric
argument serves as a repeat count. The <KBD>C-x ]</KBD> (<CODE>forward-page</CODE>)
command moves forward past the next page delimiter.
<A NAME="IDX766"></A>
<A NAME="IDX767"></A>
<P>
The <KBD>C-x C-p</KBD> command (<CODE>mark-page</CODE>) puts point at the beginning
of the current page and the mark at the end. The page delimiter at the end
is included (the mark follows it). The page delimiter at the front is
excluded (point follows it). This command can be followed by <KBD>C-w</KBD> to
kill a page which is to be moved elsewhere. If it is inserted after a page
delimiter, at a place where <KBD>C-x ]</KBD> or <KBD>C-x [</KBD> would take you, then
the page will be properly delimited before and after once again.
<P>
A numeric argument to <KBD>C-x C-p</KBD> is used to specify which page to go
to, relative to the current one. Zero means the current page. One means
the next page, and -1 means the previous one.
<A NAME="IDX768"></A>
<A NAME="IDX769"></A>
<P>
The <KBD>C-x l</KBD> command (<CODE>count-lines-page</CODE>) is good for deciding
where to break a page in two. It prints in the echo area the total number
of lines in the current page, and then divides it up into those preceding
the current line and those following, as in
<P>
<PRE>
Page has 96 (72+25) lines
</PRE>
<P>
Notice that the sum is off by one; this is correct if point is not at the
beginning of a line.
<A NAME="IDX770"></A>
<P>
The variable <CODE>page-delimiter</CODE> controls where pages begin. Its
value is a regexp that matches the beginning of a line that separates
pages. The normal value of this variable is <CODE>"^<TT>\</TT>f"</CODE>, which
matches a formfeed character at the beginning of a line.
<P>
<A NAME="IDX771"></A>
<H2><A NAME="SEC160" HREF="emacs_toc.html#SEC160">Filling Text</A></H2>
<P>
With Auto Fill mode, text can be <DFN>filled</DFN> (broken up into lines
that fit in a specified width) as you insert it. If you alter existing
text it may no longer be properly filled; then you can use the explicit
fill commands to fill the paragraph again.
<P>
<A NAME="IDX772"></A>
<A NAME="IDX773"></A>
<H3><A NAME="SEC161" HREF="emacs_toc.html#SEC161">Auto Fill Mode</A></H3>
<P>
<DFN>Auto Fill</DFN> mode is a minor mode in which lines are broken
automatically when they become too wide. Breaking happens only when
you type a <KBD>SPC</KBD> or <KBD>RET</KBD>.
<P>
<DL COMPACT>
<DT><KBD>M-x auto-fill-mode</KBD>
<DD>Enable or disable Auto Fill mode.
<DT><KBD><KBD>SPC</KBD></KBD>
<DD><DT><KBD><KBD>RET</KBD></KBD>
<DD>In Auto Fill mode, break lines when appropriate.
</DL>
<A NAME="IDX774"></A>
<P>
<KBD>M-x auto-fill-mode</KBD> turns Auto Fill mode on if it was off, or off if
it was on. With a positive numeric argument it always turns Auto Fill mode
on, and with a negative argument always turns it off. You can see when
Auto Fill mode is in effect by the presence of the word <SAMP>`Fill'</SAMP> in the
mode line, inside the parentheses. Auto Fill mode is a minor mode, turned
on or off for each buffer individually. See section <A HREF="emacs_35.html#SEC333">Minor Modes</A>.
<P>
In Auto Fill mode, lines are broken automatically at spaces when they get
longer than the desired width. Line breaking and rearrangement takes place
only when you type <KBD>SPC</KBD> or <KBD>RET</KBD>. If you wish to insert a space
or newline without permitting line-breaking, type <KBD>C-q <KBD>SPC</KBD></KBD> or
<KBD>C-q <KBD>LFD</KBD></KBD> (recall that a newline is really a linefeed). Also,
<KBD>C-o</KBD> inserts a newline without line breaking.
<P>
Auto Fill mode works well with Lisp mode, because when it makes a new
line in Lisp mode it indents that line with <KBD>TAB</KBD>. If a line ending in
a comment gets too long, the text of the comment is split into two
comment lines. Optionally new comment delimiters are inserted at the end of
the first line and the beginning of the second so that each line is
a separate comment; the variable <CODE>comment-multi-line</CODE> controls the
choice (see section <A HREF="emacs_26.html#SEC187">Manipulating Comments</A>).
<P>
Auto Fill mode does not refill entire paragraphs. It can break lines but
cannot merge lines. So editing in the middle of a paragraph can result in
a paragraph that is not correctly filled. The easiest way to make the
paragraph properly filled again is usually with the explicit fill commands.
<P>
Many users like Auto Fill mode and want to use it in all text files.
The section on init files says how to arrange this permanently for yourself.
See section <A HREF="emacs_35.html#SEC356">The Init File, <TT>`~/.emacs'</TT></A>.
<P>
<H3><A NAME="SEC162" HREF="emacs_toc.html#SEC162">Explicit Fill Commands</A></H3>
<P>
<DL COMPACT>
<DT><KBD>M-q</KBD>
<DD>Fill current paragraph (<CODE>fill-paragraph</CODE>).
<DT><KBD>C-x f</KBD>
<DD>Set the fill column (<CODE>set-fill-column</CODE>).
<DT><KBD>M-x fill-region</KBD>
<DD>Fill each paragraph in the region (<CODE>fill-region</CODE>).
<DT><KBD>M-x <API key>.</KBD>
<DD>Fill the region, considering it as one paragraph.
<DT><KBD>M-s</KBD>
<DD>Center a line.
</DL>
<A NAME="IDX775"></A>
<A NAME="IDX776"></A>
<P>
To refill a paragraph, use the command <KBD>M-q</KBD>
(<CODE>fill-paragraph</CODE>). This operates on the paragraph that point is
inside, or the one after point if point is between paragraphs.
Refilling works by removing all the line-breaks, then inserting new ones
where necessary.
<A NAME="IDX777"></A>
<A NAME="IDX778"></A>
<A NAME="IDX779"></A>
<P>
The command <KBD>M-s</KBD> (<CODE>center-line</CODE>) centers the current line
within the current fill column. With an argument, it centers several lines
individually and moves past them.
<A NAME="IDX780"></A>
<P>
To refill many paragraphs, use <KBD>M-x fill-region</KBD>, which
divides the region into paragraphs and fills each of them.
<A NAME="IDX781"></A>
<P>
<KBD>M-q</KBD> and <CODE>fill-region</CODE> use the same criteria as <KBD>M-h</KBD>
for finding paragraph boundaries (see section <A HREF="emacs_25.html#SEC158">Paragraphs</A>). For more
control, you can use <KBD>M-x <API key></KBD>, which refills
everything between point and mark. This command deletes any blank lines
within the region, so separate blocks of text end up combined into one
block.<A NAME="IDX782"></A>
<P>
A numeric argument to <KBD>M-q</KBD> causes it to <DFN>justify</DFN> the text as
well as filling it. This means that extra spaces are inserted to make
the right margin line up exactly at the fill column. To remove the
extra spaces, use <KBD>M-q</KBD> with no argument. (Likewise for
<CODE>fill-region</CODE>.)
<A NAME="IDX783"></A>
<A NAME="IDX784"></A>
<P>
When <CODE>adaptive-fill-mode</CODE> is non-<CODE>nil</CODE> (which is normally
the case), if you use <CODE><API key></CODE> on an indented
paragraph and you don't have a fill prefix, it uses the indentation of
the second line of the paragraph as the fill prefix. The effect of
adaptive filling is not noticeable in Text mode, because an indented
line counts as a paragraph starter and thus each line of an indented
paragraph is considered a paragraph of its own. But you do notice the
effect in Indented Text mode and some other major modes.
<A NAME="IDX785"></A>
<P>
The maximum line width for filling is in the variable <CODE>fill-column</CODE>.
Altering the value of <CODE>fill-column</CODE> makes it local to the current
buffer; until that time, the default value is in effect. The default is
initially 70. See section <A HREF="emacs_35.html#SEC338">Local Variables</A>.
<A NAME="IDX786"></A>
<A NAME="IDX787"></A>
<P>
The easiest way to set <CODE>fill-column</CODE> is to use the command <KBD>C-x
f</KBD> (<CODE>set-fill-column</CODE>). With no argument, it sets <CODE>fill-column</CODE>
to the current horizontal position of point. With a numeric argument, it
uses that as the new fill column.
<P>
<H3><A NAME="SEC163" HREF="emacs_toc.html#SEC163">The Fill Prefix</A></H3>
<A NAME="IDX788"></A>
<P>
To fill a paragraph in which each line starts with a special marker
(which might be a few spaces, giving an indented paragraph), use the
<DFN>fill prefix</DFN> feature. The fill prefix is a string which Emacs expects
every line to start with, and which is not included in filling.
<P>
<DL COMPACT>
<DT><KBD>C-x .</KBD>
<DD>Set the fill prefix (<CODE>set-fill-prefix</CODE>).
<DT><KBD>M-q</KBD>
<DD>Fill a paragraph using current fill prefix (<CODE>fill-paragraph</CODE>).
<DT><KBD>M-x <API key></KBD>
<DD>Fill the region, considering each change of indentation as starting a
new paragraph.
<DT><KBD>M-x <API key></KBD>
<DD>Fill the region, considering only paragraph-separator lines as starting
a new paragraph.
</DL>
<A NAME="IDX789"></A>
<A NAME="IDX790"></A>
<P>
To specify a fill prefix, move to a line that starts with the desired
prefix, put point at the end of the prefix, and give the command
<KBD>C-x .</KBD> (<CODE>set-fill-prefix</CODE>). That's a period after the
<KBD>C-x</KBD>. To turn off the fill prefix, specify an empty prefix: type
<KBD>C-x .</KBD> with point at the beginning of a line.<P>
When a fill prefix is in effect, the fill commands remove the fill prefix
from each line before filling and insert it on each line after filling.
The fill prefix is also inserted on new lines made automatically by Auto
Fill mode. Lines that do not start with the fill prefix are considered to
start paragraphs, both in <KBD>M-q</KBD> and the paragraph commands; this is
just right if you are using paragraphs with hanging indentation (every line
indented except the first one). Lines which are blank or indented once the
prefix is removed also separate or start paragraphs; this is what you want
if you are writing multi-paragraph comments with a comment delimiter on
each line.
<P>
For example, if <CODE>fill-column</CODE> is 40 and you set the fill prefix
to <SAMP>`;; '</SAMP>, then <KBD>M-q</KBD> in the following text
<P>
<PRE>
;; This is an
;; example of a paragraph
;; inside a Lisp-style comment.
</PRE>
<P>
produces this:
<P>
<PRE>
;; This is an example of a paragraph
;; inside a Lisp-style comment.
</PRE>
<P>
The <KBD>C-o</KBD> command inserts the fill prefix on new lines it creates,
when you use it at the beginning of a line (see section <A HREF="emacs_8.html#SEC25">Blank Lines</A>).
Conversely, the command <KBD>M-^</KBD> deletes the prefix (if it occurs)
after the newline that it deletes (see section <A HREF="emacs_24.html#SEC151">Indentation</A>).
<A NAME="IDX791"></A>
<P>
You can use <KBD>M-x <API key></KBD> to set the fill
prefix for each paragraph automatically. This command divides the
region into paragraphs, treating every change in the amount of
indentation as the start of a new paragraph, and fills each of these
paragraphs. Thus, all the lines in one "paragraph" have the same
amount of indentation. That indentation serves as the fill prefix for
that paragraph.
<A NAME="IDX792"></A>
<P>
<KBD>M-x <API key></KBD> is a similar command that divides
the region into paragraphs in a different way. It considers only
<API key> lines (as defined by <CODE>paragraph-separate</CODE>) as
starting a new paragraph. Since this means that the lines of one
paragraph may have different amounts of indentation, the fill prefix
used is the smallest amount of indentation of any of the lines of the
paragraph.
<A NAME="IDX793"></A>
<P>
The fill prefix is stored in the variable <CODE>fill-prefix</CODE>. Its value
is a string, or <CODE>nil</CODE> when there is no fill prefix. This is a
per-buffer variable; altering the variable affects only the current buffer,
but there is a default value which you can change as well. See section <A HREF="emacs_35.html#SEC338">Local Variables</A>.
<P>
<A NAME="IDX794"></A>
<H2><A NAME="SEC164" HREF="emacs_toc.html#SEC164">Case Conversion Commands</A></H2>
<P>
Emacs has commands for converting either a single word or any arbitrary
range of text to upper case or to lower case.
<P>
<DL COMPACT>
<DT><KBD>M-l</KBD>
<DD>Convert following word to lower case (<CODE>downcase-word</CODE>).
<DT><KBD>M-u</KBD>
<DD>Convert following word to upper case (<CODE>upcase-word</CODE>).
<DT><KBD>M-c</KBD>
<DD>Capitalize the following word (<CODE>capitalize-word</CODE>).
<DT><KBD>C-x C-l</KBD>
<DD>Convert region to lower case (<CODE>downcase-region</CODE>).
<DT><KBD>C-x C-u</KBD>
<DD>Convert region to upper case (<CODE>upcase-region</CODE>).
</DL>
<A NAME="IDX795"></A>
<A NAME="IDX796"></A>
<A NAME="IDX797"></A>
<A NAME="IDX798"></A>
<A NAME="IDX799"></A>
<A NAME="IDX800"></A>
<A NAME="IDX801"></A>
<A NAME="IDX802"></A>
<A NAME="IDX803"></A>
<P>
The word conversion commands are the most useful. <KBD>M-l</KBD>
(<CODE>downcase-word</CODE>) converts the word after point to lower case, moving
past it. Thus, repeating <KBD>M-l</KBD> converts successive words.
<KBD>M-u</KBD> (<CODE>upcase-word</CODE>) converts to all capitals instead, while
<KBD>M-c</KBD> (<CODE>capitalize-word</CODE>) puts the first letter of the word
into upper case and the rest into lower case. All these commands convert
several words at once if given an argument. They are especially convenient
for converting a large amount of text from all upper case to mixed case,
because you can move through the text using <KBD>M-l</KBD>, <KBD>M-u</KBD> or
<KBD>M-c</KBD> on each word as appropriate, occasionally using <KBD>M-f</KBD> instead
to skip a word.
<P>
When given a negative argument, the word case conversion commands apply
to the appropriate number of words before point, but do not move point.
This is convenient when you have just typed a word in the wrong case: you
can give the case conversion command and continue typing.
<P>
If a word case conversion command is given in the middle of a word, it
applies only to the part of the word which follows point. This is just
like what <KBD>M-d</KBD> (<CODE>kill-word</CODE>) does. With a negative argument,
case conversion applies only to the part of the word before point.
<A NAME="IDX804"></A>
<A NAME="IDX805"></A>
<A NAME="IDX806"></A>
<A NAME="IDX807"></A>
<P>
The other case conversion commands are <KBD>C-x C-u</KBD>
(<CODE>upcase-region</CODE>) and <KBD>C-x C-l</KBD> (<CODE>downcase-region</CODE>), which
convert everything between point and mark to the specified case. Point and
mark do not move.
<P>
The region case conversion commands <CODE>upcase-region</CODE> and
<CODE>downcase-region</CODE> are normally disabled. This means that they ask
for confirmation if you try to use them. When you confirm, you may
enable the command, which means it will not ask for confirmation again.
See section <A HREF="emacs_35.html#SEC353">Disabling Commands</A>.
<P>
<A NAME="IDX808"></A>
<A NAME="IDX809"></A>
<A NAME="IDX810"></A>
<H2><A NAME="SEC165" HREF="emacs_toc.html#SEC165">Text Mode</A></H2>
<P>
When you edit files of text in a human language, it's more convenient
to use Text mode rather than Fundamental mode. Invoke <KBD>M-x
text-mode</KBD> to enter Text mode. In Text mode, <KBD>TAB</KBD> runs the
function <CODE>tab-to-tab-stop</CODE>, which allows you to use arbitrary tab
stops set with <KBD>M-x edit-tab-stops</KBD> (see section <A HREF="emacs_24.html#SEC153">Tab Stops</A>). Features
concerned with comments in programs are turned off except when
explicitly invoked. The syntax table is changed so that periods are not
considered part of a word, while apostrophes, backspaces and underlines
are.
<A NAME="IDX811"></A>
<A NAME="IDX812"></A>
<A NAME="IDX813"></A>
<A NAME="IDX814"></A>
<P>
A similar variant mode is Indented Text mode, intended for editing
text in which most lines are indented. This mode defines <KBD>TAB</KBD> to
run <CODE>indent-relative</CODE> (see section <A HREF="emacs_24.html#SEC151">Indentation</A>), and makes Auto Fill
indent the lines it creates. The result is that normally a line made by
Auto Filling, or by <KBD>LFD</KBD>, is indented just like the previous line.
In Indented Text mode, only blank lines separate <API key>
lines continue the current paragraph. Use <KBD>M-x indented-text-mode</KBD>
to select this mode.
<A NAME="IDX815"></A>
<P>
Text mode, and all the modes based on it, define <KBD>M-<KBD>TAB</KBD></KBD> as
the command <CODE><API key></CODE>, which performs completion of
the partial word in the buffer before point, using the spelling
dictionary as the space of possible words. See section <A HREF="emacs_18.html#SEC95">Checking and Correcting Spelling</A>.
<A NAME="IDX816"></A>
<P>
Entering Text mode or Indented Text mode runs the hook
<CODE>text-mode-hook</CODE>. Other major modes related to Text mode also run
this hook, followed by hooks of their own; this includes Nroff mode,
TeX mode, Outline mode and Mail mode. Hook functions on
<CODE>text-mode-hook</CODE> can look at the value of <CODE>major-mode</CODE> to see
which of these modes is actually being entered. See section <A HREF="emacs_35.html#SEC337">Hooks</A>.
<P>
<A NAME="IDX817"></A>
<A NAME="IDX818"></A>
<A NAME="IDX819"></A>
<A NAME="IDX820"></A>
<H2><A NAME="SEC166" HREF="emacs_toc.html#SEC166">Outline Mode</A></H2>
<A NAME="IDX821"></A>
<A NAME="IDX822"></A>
<P>
Outline mode is a major mode much like Text mode but intended for
editing outlines. It allows you to make parts of the text temporarily
invisible so that you can see just the overall structure of the
outline. Type <KBD>M-x outline-mode</KBD> to switch to Outline mode as the
major mode of the current buffer. Type <KBD>M-x outline-minor-mode</KBD>
to enable Outline mode as a minor mode in the current buffer.
When Outline minor mode is enabled, the <KBD>C-c</KBD> commands of Outline
mode replace those of the major mode.
<P>
When a line is invisible in outline mode, it does not appear on the
screen. The screen appears exactly as if the invisible line
were deleted, except that an ellipsis (three periods in a row) appears
at the end of the previous visible line (only one ellipsis no matter
how many invisible lines follow).
<P>
All editing commands treat the text of the invisible line as part of the
previous visible line. For example, <KBD>C-n</KBD> moves onto the next visible
line. Killing an entire visible line, including its terminating newline,
really kills all the following invisible lines along with it; yanking it
all back yanks the invisible lines and they remain invisible.
<A NAME="IDX823"></A>
<P>
Entering Outline mode runs the hook <CODE>text-mode-hook</CODE> followed by
the hook <CODE>outline-mode-hook</CODE> (see section <A HREF="emacs_35.html#SEC337">Hooks</A>).
<P>
<H3><A NAME="SEC167" HREF="emacs_toc.html#SEC167">Format of Outlines</A></H3>
<A NAME="IDX824"></A>
<A NAME="IDX825"></A>
<P>
Outline mode assumes that the lines in the buffer are of two types:
<DFN>heading lines</DFN> and <DFN>body lines</DFN>. A heading line represents a topic in the
outline. Heading lines start with one or more stars; the number of stars
determines the depth of the heading in the outline structure. Thus, a
heading line with one star is a major topic; all the heading lines with
two stars between it and the next one-star heading are its subtopics; and
so on. Any line that is not a heading line is a body line. Body lines
belong with the preceding heading line. Here is an example:
<P>
<PRE>
* Food
This is the body,
which says something about the topic of food.
** Delicious Food
This is the body of the second-level header.
** Distasteful Food
This could have
a body too, with
several lines.
*** Dormitory Food
* Shelter
A second first-level topic with its header line.
</PRE>
<P>
A heading line together with all following body lines is called
collectively an <DFN>entry</DFN>. A heading line together with all following
deeper heading lines and their body lines is called a <DFN>subtree</DFN>.
<A NAME="IDX826"></A>
<P>
You can customize the criterion for distinguishing heading lines
by setting the variable <CODE>outline-regexp</CODE>. Any line whose
beginning has a match for this regexp is considered a heading line.
Matches that start within a line (not at the beginning) do not count.
The length of the matching text determines the level of the heading;
longer matches make a more deeply nested level. Thus, for example,
if a text formatter has commands <SAMP>`@chapter'</SAMP>, <SAMP>`@section'</SAMP>
and <SAMP>`@subsection'</SAMP> to divide the document into chapters and
sections, you could make those lines count as heading lines by
setting <CODE>outline-regexp</CODE> to <SAMP>`"@chap\\|@\\(sub\\)*section"'</SAMP>.
Note the trick: the two words <SAMP>`chapter'</SAMP> and <SAMP>`section'</SAMP> are equally
long, but by defining the regexp to match only <SAMP>`chap'</SAMP> we ensure
that the length of the text matched on a chapter heading is shorter,
so that Outline mode will know that sections are contained in chapters.
This works as long as no other command starts with <SAMP>`@chap'</SAMP>.
<P>
Outline mode makes a line invisible by changing the newline before it
into an ASCII control-M (code 015). Most editing commands that work on
lines treat an invisible line as part of the previous line because,
strictly speaking, it <EM>is</EM> part of that line, since there is no longer a
newline in between. When you save the file in Outline mode, control-M
characters are saved as newlines, so the invisible lines become ordinary
lines in the file. But saving does not change the visibility status of a
line inside Emacs.
<P>
<H3><A NAME="SEC168" HREF="emacs_toc.html#SEC168">Outline Motion Commands</A></H3>
<P>
There are some special motion commands in Outline mode that move
backward and forward to heading lines.
<P>
<DL COMPACT>
<DT><KBD>C-c C-n</KBD>
<DD>Move point to the next visible heading line
(<CODE><API key></CODE>).
<DT><KBD>C-c C-p</KBD>
<DD>Move point to the previous visible heading line <BR>
(<CODE><API key></CODE>).
<DT><KBD>C-c C-f</KBD>
<DD>Move point to the next visible heading line at the same level
as the one point is on (<CODE><API key></CODE>).
<DT><KBD>C-c C-b</KBD>
<DD>Move point to the previous visible heading line at the same level
(<CODE><API key></CODE>).
<DT><KBD>C-c C-u</KBD>
<DD>Move point up to a lower-level (more inclusive) visible heading line
(<CODE>outline-up-heading</CODE>).
</DL>
<A NAME="IDX827"></A>
<A NAME="IDX828"></A>
<A NAME="IDX829"></A>
<A NAME="IDX830"></A>
<P>
<KBD>C-c C-n</KBD> (<CODE><API key></CODE>) moves down to the next
heading line. <KBD>C-c C-p</KBD> (<CODE><API key></CODE>) moves
similarly backward. Both accept numeric arguments as repeat counts. The
names emphasize that invisible headings are skipped, but this is not really
a special feature. All editing commands that look for lines ignore the
invisible lines automatically.<A NAME="IDX831"></A>
<A NAME="IDX832"></A>
<A NAME="IDX833"></A>
<A NAME="IDX834"></A>
<A NAME="IDX835"></A>
<A NAME="IDX836"></A>
<P>
More powerful motion commands understand the level structure of headings.
<KBD>C-c C-f</KBD> (<CODE><API key></CODE>) and
<KBD>C-c C-b</KBD> (<CODE><API key></CODE>) move from one
heading line to another visible heading at the same depth in
the outline. <KBD>C-c C-u</KBD> (<CODE>outline-up-heading</CODE>) moves
backward to another heading that is less deeply nested.
<P>
<H3><A NAME="SEC169" HREF="emacs_toc.html#SEC169">Outline Visibility Commands</A></H3>
<P>
The other special commands of outline mode are used to make lines visible
or invisible. Their names all start with <CODE>hide</CODE> or <CODE>show</CODE>.
Most of them fall into pairs of opposites. They are not undoable; instead,
you can undo right past them. Making lines visible or invisible is simply
not recorded by the undo mechanism.
<P>
<DL COMPACT>
<DT><KBD>M-x hide-body</KBD>
<DD>Make all body lines in the buffer invisible.
<DT><KBD>M-x show-all</KBD>
<DD>Make all lines in the buffer visible.
<DT><KBD>C-c C-h</KBD>
<DD>Make everything under this heading invisible, not including this
heading itself<BR> (<CODE>hide-subtree</CODE>).
<DT><KBD>C-c C-s</KBD>
<DD>Make everything under this heading visible, including body,
subheadings, and their bodies (<CODE>show-subtree</CODE>).
<DT><KBD>M-x hide-leaves</KBD>
<DD>Make the body of this heading line, and of all its subheadings,
invisible.
<DT><KBD>M-x show-branches</KBD>
<DD>Make all subheadings of this heading line, at all levels, visible.
<DT><KBD>C-c C-i</KBD>
<DD>Make immediate subheadings (one level down) of this heading line
visible (<CODE>show-children</CODE>).
<DT><KBD>M-x hide-entry</KBD>
<DD>Make this heading line's body invisible.
<DT><KBD>M-x show-entry</KBD>
<DD>Make this heading line's body visible.
</DL>
<A NAME="IDX837"></A>
<A NAME="IDX838"></A>
<P>
Two commands that are exact opposites are <KBD>M-x hide-entry</KBD> and
<KBD>M-x show-entry</KBD>. They are used with point on a heading line, and
apply only to the body lines of that heading. The subtopics and their
bodies are not affected.
<A NAME="IDX839"></A>
<A NAME="IDX840"></A>
<A NAME="IDX841"></A>
<A NAME="IDX842"></A>
<A NAME="IDX843"></A>
<P>
Two more powerful opposites are <KBD>C-c C-h</KBD> (<CODE>hide-subtree</CODE>) and
<KBD>C-c C-s</KBD> (<CODE>show-subtree</CODE>). Both expect to be used when point is
on a heading line, and both apply to all the lines of that heading's
<DFN>subtree</DFN>: its body, all its subheadings, both direct and indirect, and
all of their bodies. In other words, the subtree contains everything
following this heading line, up to and not including the next heading of
the same or higher rank.<A NAME="IDX844"></A>
<A NAME="IDX845"></A>
<P>
Intermediate between a visible subtree and an invisible one is having
all the subheadings visible but none of the body. There are two commands
for doing this, depending on whether you want to hide the bodies or
make the subheadings visible. They are <KBD>M-x hide-leaves</KBD> and
<KBD>M-x show-branches</KBD>.
<A NAME="IDX846"></A>
<A NAME="IDX847"></A>
<P>
A little weaker than <CODE>show-branches</CODE> is <KBD>C-c C-i</KBD>
(<CODE>show-children</CODE>). It makes just the direct subheadings
visible--those one level down. Deeper subheadings remain invisible, if
they were invisible.<A NAME="IDX848"></A>
<A NAME="IDX849"></A>
<P>
Two commands have a blanket effect on the whole file. <KBD>M-x hide-body</KBD>
makes all body lines invisible, so that you see just the outline structure.
<KBD>M-x show-all</KBD> makes all lines visible. These commands can be thought
of as a pair of opposites even though <KBD>M-x show-all</KBD> applies to more
than just body lines.
<P>
You can turn off the use of ellipses at the ends of visible lines by
setting <CODE><API key></CODE> to <CODE>nil</CODE>. Then there is
no visible indication of the presence of invisible lines.
<P>
<A NAME="IDX850"></A>
<A NAME="IDX851"></A>
<A NAME="IDX852"></A>
<A NAME="IDX853"></A>
<A NAME="IDX854"></A>
<A NAME="IDX855"></A>
<A NAME="IDX856"></A>
<H2><A NAME="SEC170" HREF="emacs_toc.html#SEC170">TeX Mode</A></H2>
<P>
TeX is a powerful text formatter written by Donald Knuth; it is also
free, like GNU Emacs. LaTeX is a simplified input format for TeX,
implemented by TeX macros; it comes with TeX. SliTeX is a special
form of LaTeX.<P>
Emacs has a special TeX mode for editing TeX input files.
It provides facilities for checking the balance of delimiters and for
invoking TeX on all or part of the file.
<A NAME="IDX857"></A>
<P>
TeX mode has three variants, Plain TeX mode, LaTeX mode, and
SliTeX mode (these three distinct major modes differ only slightly).
They are designed for editing the three different formats. The command
<KBD>M-x tex-mode</KBD> looks at the contents of the buffer to determine
whether the contents appear to be either LaTeX input or SliTeX
input; it then selects the appropriate mode. If it can't tell which is
right (e.g., the buffer is empty), the variable <CODE>tex-default-mode</CODE>
controls which mode is used.
<P>
When <KBD>M-x tex-mode</KBD> does not guess right, you can use the commands
<KBD>M-x plain-tex-mode</KBD>, <KBD>M-x latex-mode</KBD>, and <KBD>M-x
slitex-mode</KBD> to select explicitly the particular variants of TeX
mode.
<P>
<H3><A NAME="SEC171" HREF="emacs_toc.html#SEC171">TeX Editing Commands</A></H3>
<P>
Here are the special commands provided in TeX mode for editing the
text of the file.
<P>
<DL COMPACT>
<DT><KBD>"</KBD>
<DD>Insert, according to context, either <SAMP>`"'</SAMP> or <SAMP>`"'</SAMP> or
<SAMP>`"'</SAMP> (<CODE>tex-insert-quote</CODE>).
<DT><KBD><KBD>LFD</KBD></KBD>
<DD>Insert a paragraph break (two newlines) and check the previous
paragraph for unbalanced braces or dollar signs
(<CODE><API key></CODE>).
<DT><KBD>M-x validate-tex-region</KBD>
<DD>Check each paragraph in the region for unbalanced braces or dollar signs.
<DT><KBD>C-c {</KBD>
<DD>Insert <SAMP>`{}'</SAMP> and position point between them (<CODE>tex-insert-braces</CODE>).
<DT><KBD>C-c }</KBD>
<DD>Move forward past the next unmatched close brace (<CODE>up-list</CODE>).
</DL>
<A NAME="IDX858"></A>
<A NAME="IDX859"></A>
<P>
In TeX, the character <SAMP>`"'</SAMP> is not normally used; we use
<SAMP>`"'</SAMP> to start a quotation and <SAMP>`"'</SAMP> to end one. To make
editing easier under this formatting convention, TeX mode overrides
the normal meaning of the key <KBD>"</KBD> with a command that inserts a pair
of single-quotes or backquotes (<CODE>tex-insert-quote</CODE>). To be
precise, this command inserts <SAMP>`"'</SAMP> after whitespace or an open
brace, <SAMP>`"'</SAMP> after a backslash, and <SAMP>`"'</SAMP> after any other
character.
<P>
If you need the character <SAMP>`"'</SAMP> itself in unusual contexts, use
<KBD>C-q</KBD> to insert it. Also, <KBD>"</KBD> with a numeric argument always
inserts that number of <SAMP>`"'</SAMP> characters.
<P>
In TeX mode, <SAMP>`$'</SAMP> has a special syntax code which attempts to
understand the way TeX math mode delimiters match. When you insert a
<SAMP>`$'</SAMP> that is meant to exit math mode, the position of the matching
<SAMP>`$'</SAMP> that entered math mode is displayed for a second. This is the
same feature that displays the open brace that matches a close brace that
is inserted. However, there is no way to tell whether a <SAMP>`$'</SAMP> enters
math mode or leaves it; so when you insert a <SAMP>`$'</SAMP> that enters math
mode, the previous <SAMP>`$'</SAMP> position is shown as if it were a match, even
though they are actually unrelated.
<A NAME="IDX860"></A>
<A NAME="IDX861"></A>
<A NAME="IDX862"></A>
<A NAME="IDX863"></A>
<P>
TeX uses braces as delimiters that must match. Some users prefer
to keep braces balanced at all times, rather than inserting them
singly. Use <KBD>C-c {</KBD> (<CODE>tex-insert-braces</CODE>) to insert a pair of
braces. It leaves point between the two braces so you can insert the
text that belongs inside. Afterward, use the command <KBD>C-c }</KBD>
(<CODE>up-list</CODE>) to move forward past the close brace.
<A NAME="IDX864"></A>
<A NAME="IDX865"></A>
<A NAME="IDX866"></A>
<P>
There are two commands for checking the matching of braces. <KBD>LFD</KBD>
(<CODE><API key></CODE>) checks the paragraph before point, and
inserts two newlines to start a new paragraph. It prints a message in the
echo area if any mismatch is found. <KBD>M-x validate-tex-region</KBD> checks
a region, paragraph by paragraph. When it finds a paragraph that
contains a mismatch, it displays point at the beginning of the paragraph
for a few seconds and pushes a mark at that spot. Scanning continues
until the whole buffer has been checked or until you type another key.
The positions of the last several paragraphs with mismatches can be
found in the mark ring (see section <A HREF="emacs_13.html#SEC52">The Mark Ring</A>).
<P>
Note that Emacs commands count square brackets and parentheses in
TeX mode, not just braces. This is not strictly correct for the
purpose of checking TeX syntax. However, parentheses and square
brackets are likely to be used in text as matching delimiters and it is
useful for the various motion commands and automatic match display to
work with them.
<P>
<H3><A NAME="SEC172" HREF="emacs_toc.html#SEC172">LaTeX Editing Commands</A></H3>
<P>
LaTeX mode provides a few extra features not applicable to plain
TeX.
<P>
<DL COMPACT>
<DT><KBD>C-c C-o</KBD>
<DD>Insert <SAMP>`\begin'</SAMP> and <SAMP>`\end'</SAMP> for LaTeX block and position
point on a line between them. (<CODE>tex-latex-block</CODE>).
<DT><KBD>C-c C-e</KBD>
<DD>Close the last unended block for LaTeX (<CODE><API key></CODE>).
</DL>
<A NAME="IDX867"></A>
<A NAME="IDX868"></A>
<P>
In LaTeX input, <SAMP>`\begin'</SAMP> and <SAMP>`\end'</SAMP> commands are used to
group blocks of text. To insert a <SAMP>`\begin'</SAMP> and a matching
<SAMP>`\end'</SAMP> (on a new line following the <SAMP>`\begin'</SAMP>), use <KBD>C-c
C-o</KBD> (<CODE>tex-latex-block</CODE>). A blank line is inserted between the
two, and point is left there.<A NAME="IDX869"></A>
<P>
Emacs knows all of the standard LaTeX block names and will
permissively complete a partially entered block name
(see section <A HREF="emacs_10.html#SEC33">Completion</A>). You can add your own list of block names to those
known by Emacs with the variable <CODE>latex-block-names</CODE>. For example,
to add <SAMP>`theorem'</SAMP>, <SAMP>`corollary'</SAMP>, and <SAMP>`proof'</SAMP>, include the line
<P>
<PRE>
(setq latex-block-names '("theorem" "corollary" "proof"))
</PRE>
<P>
to your <TT>`.emacs'</TT> file.
<A NAME="IDX870"></A>
<A NAME="IDX871"></A>
<P>
In LaTeX input, <SAMP>`\begin'</SAMP> and <SAMP>`\end'</SAMP> commands must balance.
You can use <KBD>C-c C-e</KBD> (<CODE><API key></CODE>) to insert
automatically a matching <SAMP>`\end'</SAMP> to match the last unmatched <SAMP>`\begin'</SAMP>.
The <SAMP>`\end'</SAMP> will be indented to match the corresponding <SAMP>`\begin'</SAMP>.
The <SAMP>`\end'</SAMP> will be followed by a newline if point is at the beginning
of a line.<P>
<H3><A NAME="SEC173" HREF="emacs_toc.html#SEC173">TeX Printing Commands</A></H3>
<P>
You can invoke TeX as an inferior of Emacs on either the entire
contents of the buffer or just a region at a time. Running TeX in
this way on just one chapter is a good way to see what your changes
look like without taking the time to format the entire file.
<P>
<DL COMPACT>
<DT><KBD>C-c C-r</KBD>
<DD>Invoke TeX on the current region, together with the buffer's header
(<CODE>tex-region</CODE>).
<DT><KBD>C-c C-b</KBD>
<DD>Invoke TeX on the entire current buffer (<CODE>tex-buffer</CODE>).
<DT><KBD>C-c TAB</KBD>
<DD>Invoke BibTeX on the current file (<CODE>tex-bibtex-file</CODE>).
<DT><KBD>C-c C-f</KBD>
<DD>Invoke TeX on the current file (<CODE>tex-file</CODE>).
<DT><KBD>C-c C-l</KBD>
<DD>Recenter the window showing output from the inferior TeX so that
the last line can be seen (<CODE><API key></CODE>).
<DT><KBD>C-c C-k</KBD>
<DD>Kill the TeX subprocess (<CODE>tex-kill-job</CODE>).
<DT><KBD>C-c C-p</KBD>
<DD>Print the output from the last <KBD>C-c C-r</KBD>, <KBD>C-c C-b</KBD>, or <KBD>C-c
C-f</KBD> command (<CODE>tex-print</CODE>).
<DT><KBD>C-c C-v</KBD>
<DD>Preview the output from the last <KBD>C-c C-r</KBD>, <KBD>C-c C-b</KBD>, or <KBD>C-c
C-f</KBD> command (<CODE>tex-view</CODE>).
<DT><KBD>C-c C-q</KBD>
<DD>Show the printer queue (<CODE><API key></CODE>).
</DL>
<A NAME="IDX872"></A>
<A NAME="IDX873"></A>
<A NAME="IDX874"></A>
<A NAME="IDX875"></A>
<A NAME="IDX876"></A>
<A NAME="IDX877"></A>
<A NAME="IDX878"></A>
<A NAME="IDX879"></A>
<P>
You can pass the current buffer through an inferior TeX by means of
<KBD>C-c C-b</KBD> (<CODE>tex-buffer</CODE>). The formatted output appears in a
temporary; to print it, type <KBD>C-c C-p</KBD> (<CODE>tex-print</CODE>).
Afterward use <KBD>C-c C-q</KBD> (<CODE><API key></CODE>) to view the
progress of your output towards being printed. If your terminal has the
ability to display TeX output files, you can preview the output on
the terminal with <KBD>C-c C-v</KBD> (<CODE>tex-view</CODE>).
<A NAME="IDX880"></A>
<A NAME="IDX881"></A>
<P>
You can specify the directory to use for running TeX by setting the
variable <CODE>tex-directory</CODE>. <CODE>"."</CODE> is the default value. If
your environment variable <CODE>TEXINPUTS</CODE> contains relative directory
names, or if your files contains <SAMP>`\input'</SAMP> commands with relative
file names, then <CODE>tex-directory</CODE> <EM>must</EM> be <CODE>"."</CODE> or you
will get the wrong results. Otherwise, it is safe to specify some other
directory, such as <TT>`/tmp'</TT>.
<A NAME="IDX882"></A>
<A NAME="IDX883"></A>
<A NAME="IDX884"></A>
<A NAME="IDX885"></A>
<A NAME="IDX886"></A>
<A NAME="IDX887"></A>
<P>
If you want to specify which shell commands are used in the inferior TeX,
you can do so by setting the values of the variables <CODE>tex-run-command</CODE>,
<CODE>latex-run-command</CODE>, <CODE>slitex-run-command</CODE>,
<CODE><API key></CODE>, <CODE><API key></CODE>, and
<CODE><API key></CODE>. You <EM>must</EM> set the value of
<CODE><API key></CODE> for your particular terminal; this variable
has no default value. The other variables have default values that may
(or may not) be appropriate for your system.
<P>
Normally, the file name given to these commands comes at the end of
the command string; for example, <SAMP>`latex <VAR>filename</VAR>'</SAMP>. In some
cases, however, the file name needs to be embedded in the command; an
example is when you need to provide the file name as an argument to one
command whose output is piped to another. You can specify where to put
the file name with <SAMP>`*'</SAMP> in the command string. For example,
<P>
<PRE>
(setq <API key> "dvips -f * | lpr")
</PRE>
<A NAME="IDX888"></A>
<A NAME="IDX889"></A>
<A NAME="IDX890"></A>
<A NAME="IDX891"></A>
<P>
The terminal output from TeX, including any error messages, appears
in a buffer called <SAMP>`*tex-shell*'</SAMP>. If TeX gets an error, you can
switch to this buffer and feed it input (this works as in Shell mode;
see section <A HREF="emacs_34.html#SEC316">Interactive Inferior Shell</A>). Without switching to this buffer you can
scroll it so that its last line is visible by typing <KBD>C-c
C-l</KBD>.
<P>
Type <KBD>C-c C-k</KBD> (<CODE>tex-kill-job</CODE>) to kill the TeX process if
you see that its output is no longer useful. Using <KBD>C-c C-b</KBD> or
<KBD>C-c C-r</KBD> also kills any TeX process still running.<A NAME="IDX892"></A>
<A NAME="IDX893"></A>
<P>
You can also pass an arbitrary region through an inferior TeX by typing
<KBD>C-c C-r</KBD> (<CODE>tex-region</CODE>). This is tricky, however, because most files
of TeX input contain commands at the beginning to set parameters and
define macros, without which no later part of the file will format
correctly. To solve this problem, <KBD>C-c C-r</KBD> allows you to designate a
part of the file as containing essential commands; it is included before
the specified region as part of the input to TeX. The designated part
of the file is called the <DFN>header</DFN>.
<A NAME="IDX894"></A>
<P>
To indicate the bounds of the header in Plain TeX mode, you insert two
special strings in the file. Insert <SAMP>`%**start of header'</SAMP> before the
header, and <SAMP>`%**end of header'</SAMP> after it. Each string must appear
entirely on one line, but there may be other text on the line before or
after. The lines containing the two strings are included in the header.
If <SAMP>`%**start of header'</SAMP> does not appear within the first 100 lines of
the buffer, <KBD>C-c C-r</KBD> assumes that there is no header.
<P>
In LaTeX mode, the header begins with <SAMP>`\documentstyle'</SAMP> and ends
with <SAMP>`\begin{document}'</SAMP>. These are commands that LaTeX requires
you to use in any case, so nothing special needs to be done to identify the
header.
<A NAME="IDX895"></A>
<A NAME="IDX896"></A>
<P>
The commands (<CODE>tex-buffer</CODE>) and (<CODE>tex-region</CODE>) do all of their
work in a temporary directory, and do not have available any of the auxiliary
files needed by TeX for cross-references; these commands are generally
not suitable for running the final copy in which all of the cross-references
need to be correct. When you want the auxiliary files, use <KBD>C-c C-f</KBD>
(<CODE>tex-file</CODE>) which runs TeX on the current buffer's file, in that
file's directory. Before TeX runs, you will be asked about saving
any modified buffers. Generally, you need to use (<CODE>tex-file</CODE>)
twice to get cross-references correct.
<A NAME="IDX897"></A>
<A NAME="IDX898"></A>
<A NAME="IDX899"></A>
<P>
For LaTeX files, you can use BibTeX to process the auxiliary
file for the current buffer's file. BibTeX looks up bibliographic
citations in a data base and prepares the cited references for the
bibliography section. The command <KBD>C-c TAB</KBD>
(<CODE>tex-bibtex-file</CODE>) runs the shell command
(<CODE>tex-bibtex-command</CODE>) to produce a <SAMP>`.bbl'</SAMP> file for the
current buffer's file. Generally, you need to do <KBD>C-c C-f</KBD>
(<CODE>tex-file</CODE>) once to generate the <SAMP>`.aux'</SAMP> file, then do
<KBD>C-c TAB</KBD> (<CODE>tex-bibtex-file</CODE>), and then repeat <KBD>C-c C-f</KBD>
(<CODE>tex-file</CODE>) twice more to get the cross-references correct.
<A NAME="IDX900"></A>
<A NAME="IDX901"></A>
<A NAME="IDX902"></A>
<A NAME="IDX903"></A>
<A NAME="IDX904"></A>
<P>
Entering any kind of TeX mode runs the hooks <CODE>text-mode-hook</CODE>
and <CODE>tex-mode-hook</CODE>. Then it runs either
<CODE>plain-tex-mode-hook</CODE> or <CODE>latex-mode-hook</CODE>, whichever is
appropriate. For SliTeX files, it calls <CODE>slitex-mode-hook</CODE>.
Starting the TeX shell runs the hook <CODE>tex-shell-hook</CODE>.
See section <A HREF="emacs_35.html#SEC337">Hooks</A>.
<P>
<H3><A NAME="SEC174" HREF="emacs_toc.html#SEC174">Unix TeX Distribution</A></H3>
<P>
TeX for Unix systems can be obtained from the University of Washington
for a distribution fee.
<P>
To order a full distribution, send $200.00 for a 1/2-inch 9-track 1600
bpi (tar or cpio) tape reel, or $210.00 for a 1/4-inch 4-track QIC-24
(tar or cpio) cartridge, payable to the University of Washington to:
<P>
<PRE>
Northwest Computing Support Center
DR-10, Thomson Hall 35
University of Washington
Seattle, Washington 98195
</PRE>
<P>
Purchase orders are acceptable, but there is an extra charge of
$10.00, to pay for processing charges.
<P>
For overseas orders please add $20.00 to the base cost for shipment via
air parcel post, or $30.00 for shipment via courier.
<P>
The normal distribution is a tar tape, blocked 20, 1600 bpi, on an
industry standard 2400 foot half-inch reel. The physical format for
the 1/4 inch streamer cartridges uses QIC-11, 8000 bpi, 4-track
serpentine recording for the SUN. Also, System V tapes can be written
in cpio format, blocked 5120 bytes, ASCII headers.
<P>
<H2><A NAME="SEC175" HREF="emacs_toc.html#SEC175">Nroff Mode</A></H2>
<A NAME="IDX905"></A>
<A NAME="IDX906"></A>
<P>
Nroff mode is a mode like Text mode but modified to handle nroff commands
present in the text. Invoke <KBD>M-x nroff-mode</KBD> to enter this mode. It
differs from Text mode in only a few ways. All nroff command lines are
considered paragraph separators, so that filling will never garble the
nroff commands. Pages are separated by <SAMP>`.bp'</SAMP> commands. Comments
start with <API key>. Also, three special commands are
provided that are not in Text mode:
<A NAME="IDX907"></A>
<A NAME="IDX908"></A>
<A NAME="IDX909"></A>
<A NAME="IDX910"></A>
<A NAME="IDX911"></A>
<A NAME="IDX912"></A>
<P>
<DL COMPACT>
<DT><KBD>M-n</KBD>
<DD>Move to the beginning of the next line that isn't an nroff command
(<CODE>forward-text-line</CODE>). An argument is a repeat count.
<DT><KBD>M-p</KBD>
<DD>Like <KBD>M-n</KBD> but move up (<CODE>backward-text-line</CODE>).
<DT><KBD>M-?</KBD>
<DD>Prints in the echo area the number of text lines (lines that are not
nroff commands) in the region (<CODE>count-text-lines</CODE>).
</DL>
<A NAME="IDX913"></A>
<P>
The other feature of Nroff mode is that you can turn on Electric Nroff
mode. This is a minor mode that you can turn on or off with <KBD>M-x
electric-nroff-mode</KBD> (see section <A HREF="emacs_35.html#SEC333">Minor Modes</A>). When the mode is on, each
time you use <KBD>RET</KBD> to end a line that contains an nroff command that
opens a kind of grouping, the matching nroff command to close that
grouping is automatically inserted on the following line. For example,
if you are at the beginning of a line and type <KBD>. ( b <KBD>RET</KBD></KBD>,
this inserts the matching command <SAMP>`.)b'</SAMP> on a new line following
point.
<A NAME="IDX914"></A>
<P>
Entering Nroff mode runs the hook <CODE>text-mode-hook</CODE>, followed by
the hook <CODE>nroff-mode-hook</CODE> (see section <A HREF="emacs_35.html#SEC337">Hooks</A>).
<P>Go to the <A HREF="emacs_24.html">previous</A>, <A HREF="emacs_26.html">next</A> section.<P>
|
SELECT
id_registrazione,
dat_registrazione,
des_registrazione
FROM contabilita.registrazione
WHERE id_cliente = %id_cliente%
AND num_fattura = '%num_fattura%'
AND dat_registrazione = '%dat_registrazione%'
AND extract(year from dat_registrazione) = extract(year from current_date)
|
#ifndef MATRIX_HPP
#define MATRIX_HPP
double matrix_prob_ts(int i, int j, int q, const cdf &p,
const pmf &u);
double <API key>(int i, int j, int q, const cdf &p,
const pmf &u);
void compute_matrixes(const MatrixXd & mat, int dim, MatrixXd & B, MatrixXd & A0,
MatrixXd & A1, MatrixXd & A2);
#endif
|
from __future__ import print_function
"""
Deprecated. Use ``update-tld-names`` command instead.
"""
__title__ = 'tld.update'
__author__ = 'Artur Barseghyan'
__copyright__ = '2013-2015 Artur Barseghyan'
__license__ = 'GPL 2.0/LGPL 2.1'
from tld.utils import update_tld_names
_ = lambda x: x
if __name__ == '__main__':
update_tld_names()
print(_("Local TLD names file has been successfully updated!"))
|
<?php
namespace App\Team\GET;
class Project extends Content{
public function analyze(){
$param = [];
if(empty($_GET['begin']) && empty($_GET['end']) ){
$param['begin'] = time() - 86400 * 30;
$param['end'] = time();
}else{
$param['begin'] = strtotime(self::g('begin'). '00:00:00');
$param['end'] = strtotime(self::g('end'). '23:59:59');
}
$result = self::db('project AS p')
->field('p.project_id AS id, p.project_title AS name, t.task_status, COUNT(t.task_status) AS total ')
->join("{$this->prefix}task AS t ON t.task_project_id = p.project_id")
->where("t.task_submit_time BETWEEN :begin AND :end")
->group('p.project_id, t.task_status')
->select($param);
$list = [];
$project = \Model\Content::listContent(['table' => 'project', 'order' => 'project_listsort ASC, project_id DESC']);
foreach ($project as $item){
$list[$item['project_id']]['name'] = $item['project_title'];
}
if(!empty($result)){
foreach ($result as $value){
if(empty($list[$value['id']]['total'])){
$list[$value['id']]['total'] = 0;
}
$list[$value['id']]['total'] += $value['total'];
$list[$value['id']]['task_status'][$value['task_status']] = $value['total'];
}
}
$this->assign('title', '');
$this->assign('list', $list);
$this->layout('User/User_analyze');
}
}
|
/* $Id: <API key>.c $ */
/** @file
* IPRT - Multiprocessor Event Notifications, Ring-0 Driver, Solaris.
*/
#include "the-solaris-kernel.h"
#include "internal/iprt.h"
#include <iprt/err.h>
#include <iprt/mp.h>
#include <iprt/cpuset.h>
#include <iprt/string.h>
#include <iprt/thread.h>
#include "r0drv/mp-r0drv.h"
/** Whether CPUs are being watched or not. */
static volatile bool g_fSolCpuWatch = false;
/** Set of online cpus that is maintained by the MP callback.
* This avoids locking issues querying the set from the kernel as well as
* eliminating any uncertainty regarding the online status during the
* callback. */
RTCPUSET g_rtMpSolCpuSet;
/**
* Internal solaris representation for watching CPUs.
*/
typedef struct RTMPSOLWATCHCPUS
{
/** Function pointer to Mp worker. */
PFNRTMPWORKER pfnWorker;
/** Argument to pass to the Mp worker. */
void *pvArg;
} RTMPSOLWATCHCPUS;
typedef RTMPSOLWATCHCPUS *PRTMPSOLWATCHCPUS;
/**
* Solaris callback function for Mp event notification.
*
* @returns Solaris error code.
* @param CpuState The current event/state of the CPU.
* @param iCpu Which CPU is this event for.
* @param pvArg Ignored.
*
* @remarks This function assumes index == RTCPUID.
* We may -not- be firing on the CPU going online/offline and called
* with preemption enabled.
*/
static int <API key>(cpu_setup_t CpuState, int iCpu, void *pvArg)
{
RTMPEVENT enmMpEvent;
/*
* Update our CPU set structures first regardless of whether we've been
* scheduled on the right CPU or not, this is just atomic accounting.
*/
if (CpuState == CPU_ON)
{
enmMpEvent = RTMPEVENT_ONLINE;
RTCpuSetAdd(&g_rtMpSolCpuSet, iCpu);
}
else if (CpuState == CPU_OFF)
{
enmMpEvent = RTMPEVENT_OFFLINE;
RTCpuSetDel(&g_rtMpSolCpuSet, iCpu);
}
else
return 0;
<API key>(enmMpEvent, iCpu);
NOREF(pvArg);
return 0;
}
DECLHIDDEN(int) <API key>(void)
{
if (ASMAtomicReadBool(&g_fSolCpuWatch) == true)
return VERR_WRONG_ORDER;
/*
* Register the callback building the online cpu set as we do so.
*/
RTCpuSetEmpty(&g_rtMpSolCpuSet);
mutex_enter(&cpu_lock);
<API key>(<API key>, NULL /* pvArg */);
for (int i = 0; i < (int)RTMpGetCount(); ++i)
if (cpu_is_online(cpu[i]))
<API key>(CPU_ON, i, NULL /* pvArg */);
ASMAtomicWriteBool(&g_fSolCpuWatch, true);
mutex_exit(&cpu_lock);
return VINF_SUCCESS;
}
DECLHIDDEN(void) <API key>(void)
{
if (ASMAtomicReadBool(&g_fSolCpuWatch) == true)
{
mutex_enter(&cpu_lock);
<API key>(<API key>, NULL /* pvArg */);
ASMAtomicWriteBool(&g_fSolCpuWatch, false);
mutex_exit(&cpu_lock);
}
}
|
<ul class="tw">
<?php foreach ($rows as $id => $row) { ?>
<li><?php print $row; ?></li>
<?php } ?>
</ul>
|
(function($) {
function ACFTableField() {
var t = this;
t.version = '1.3.4';
t.param = {};
// DIFFERENT IN ACF VERSION 4 and 5 {
t.param.classes = {
btn_small: 'acf-icon small',
// "acf-icon-plus" becomes "-plus" since ACF Pro Version 5.3.2
btn_add_row: 'acf-icon-plus -plus',
btn_add_col: 'acf-icon-plus -plus',
btn_remove_row: 'acf-icon-minus -minus',
btn_remove_col: 'acf-icon-minus -minus',
};
t.param.htmlbuttons = {
add_row: '<a href="#" class="acf-table-add-row ' + t.param.classes.btn_small + ' ' + t.param.classes.btn_add_row + '"></a>',
remove_row: '<a href="#" class="<API key> ' + t.param.classes.btn_small + ' ' + t.param.classes.btn_remove_row + '"></a>',
add_col: '<a href="#" class="acf-table-add-col ' + t.param.classes.btn_small + ' ' + t.param.classes.btn_add_col + '"></a>',
remove_col: '<a href="#" class="<API key> ' + t.param.classes.btn_small + ' ' + t.param.classes.btn_remove_row + '"></a>',
};
t.param.htmltable = {
body_row: '<div class="acf-table-body-row">' +
'<div class="acf-table-body-left">' +
t.param.htmlbuttons.add_row +
'<div class="acf-table-body-cont"></div>' +
'</div>' +
'<div class="<API key>">' +
t.param.htmlbuttons.remove_row +
'</div>' +
'</div>',
top_cell: '<div class="acf-table-top-cell" data-colparam="">' +
t.param.htmlbuttons.add_col +
'<div class="acf-table-top-cont"></div>' +
'</div>',
header_cell: '<div class="<API key>">' +
'<div class="<API key>"></div>' +
'</div>',
body_cell: '<div class="acf-table-body-cell">' +
'<div class="acf-table-body-cont"></div>' +
'</div>',
bottom_cell: '<div class="<API key>">' +
t.param.htmlbuttons.remove_col +
'</div>',
table: '<div class="acf-table-wrap">' +
'<div class="acf-table-table">' + // <API key> acf-table-hide-left acf-table-hide-top
'<div class="acf-table-top-row">' +
'<div class="acf-table-top-left">' +
t.param.htmlbuttons.add_col +
'</div>' +
'<div class="acf-table-top-right"></div>' +
'</div>' +
'<div class="<API key> <API key>">' +
'<div class="<API key>">' +
t.param.htmlbuttons.add_row +
'</div>' +
'<div class="<API key>"></div>' +
'</div>' +
'<div class="<API key>">' +
'<div class="<API key>"></div>' +
'<div class="<API key>"></div>' +
'</div>' +
'</div>' +
'</div>',
};
t.param.htmleditor = '<div class="<API key>">' +
'<textarea name="<API key>" class="<API key>"></textarea>' +
'</div>';
t.obj = {
body: $( 'body' ),
};
t.var = {
ajax: false,
};
t.state = {
'current_cell_obj': false,
'cell_editor_cell': false,
'<API key>': false
};
t.init = function() {
t.init_workflow();
};
t.init_workflow = function() {
t.each_table();
t.table_add_col_event();
t.table_remove_col();
t.table_add_row_event();
t.table_remove_row();
t.cell_editor();
t.<API key>();
t.prevent_cell_links();
t.sortable_row();
t.sortable_col();
t.ui_event_use_header();
t.ui_event_caption();
t.<API key>();
t.<API key>();
t.ui_event_ajax();
};
t.ui_event_ajax = function() {
$( document ).ajaxComplete( function( event ) {
t.each_table();
});
}
t.<API key> = function() {
t.obj.body.on( 'change', '[name="post_category[]"], [name="post_format"], [name="page_template"], [name="parent_id"], [name="role"], [name^="tax_input"]', function() {
var interval = setInterval( function() {
var table_fields = $( '.field_type-table' );
if ( table_fields.length > 0 ) {
t.each_table();
clearInterval( interval );
}
}, 100 );
} );
};
t.each_table = function( ) {
$( '.acf-field-table .acf-table-root' ).not( '.acf-table-rendered' ).each( function() {
var p = {};
p.obj_root = $( this ),
table = p.obj_root.find( '.acf-table-wrap' );
if ( table.length > 0 ) {
return;
}
p.obj_root.addClass( 'acf-table-rendered' );
t.data_get( p );
t.data_default( p );
t.field_options_get( p );
t.table_render( p );
t.misc_render( p );
if ( typeof p.data.b[ 1 ] === 'undefined' && typeof p.data.b[ 0 ][ 1 ] === 'undefined' && p.data.b[ 0 ][ 0 ].c === '' ) {
p.obj_root.find( '.<API key>' ).hide(),
p.obj_root.find( '.<API key>' ).hide();
}
} );
};
t.field_options_get = function( p ) {
try {
p.field_options = $.parseJSON( decodeURIComponent( p.obj_root.find( '[data-field-options]' ).data( 'field-options' ) ) );
}
catch (e) {
p.field_options = {
use_header: 2
};
console.log( 'The tablefield options value is not a valid JSON string:', decodeURIComponent( p.obj_root.find( '[data-field-options]' ).data( 'field-options' ) ) );
console.log( 'The parsing error:', e );
}
};
t.ui_event_use_header = function() {
// HEADER: SELECT FIELD ACTIONS {
t.obj.body.on( 'change', '.<API key>', function() {
var that = $( this ),
p = {};
p.obj_root = that.parents( '.acf-table-root' );
p.obj_table = p.obj_root.find( '.acf-table-table' );
t.data_get( p );
t.data_default( p );
if ( that.val() === '1' ) {
p.obj_table.removeClass( '<API key>' );
p.data.p.o.uh = 1;
t.<API key>( p );
}
else {
p.obj_table.addClass( '<API key>' );
p.data.p.o.uh = 0;
t.<API key>( p );
}
} );
};
t.ui_event_caption = function() {
// CAPTION: INPUT FIELD ACTIONS {
t.obj.body.on( 'change', '.<API key>', function() {
var that = $( this ),
p = {};
p.obj_root = that.parents( '.acf-table-root' );
p.obj_table = p.obj_root.find( '.acf-table-table' );
t.data_get( p );
t.data_default( p );
p.data.p.ca = that.val();
t.<API key>( p );
} );
};
t.<API key> = function() {
t.obj.body.on( 'click', '.acf-fc-popup', function() {
// SORTABLE {
$( '.acf-table-table' )
.sortable('destroy')
.unbind();
window.setTimeout( function() {
t.sortable_row();
}, 300 );
} );
};
t.data_get = function( p ) {
// DATA FROM FIELD {
var val = p.obj_root.find( 'input.table' ).val();
p.data = false;
// CHECK FIELD CONTEXT {
if ( p.obj_root.closest( '.acf-fields' ).hasClass( 'acf-block-fields' ) ) {
p.field_context = 'block';
}
else {
p.field_context = 'box';
}
if ( val !== '' ) {
try {
if ( p.field_context === 'box' ) {
p.data = $.parseJSON( decodeURIComponent( val.replace(/\+/g, '%20') ) );
}
if ( p.field_context === 'block' ) {
p.data = $.parseJSON( decodeURIComponent( decodeURIComponent( val.replace(/\+/g, '%20') ) ) );
}
}
catch (e) {
if ( p.field_context === 'box' ) {
console.log( 'The tablefield value is not a valid JSON string:', decodeURIComponent( val.replace(/\+/g, '%20') ) );
console.log( 'The parsing error:', e );
}
if ( p.field_context === 'block' ) {
console.log( 'The tablefield value is not a valid JSON string:', decodeURIComponent( decodeURIComponent( val.replace(/\+/g, '%20') ) ) );
console.log( 'The tablefield value is not a valid JSON string:', decodeURIComponent( decodeURIComponent( decodeURIComponent( val.replace(/\+/g, '%20') ) ) ) );
console.log( 'The parsing error:', e );
}
}
}
return p.data;
};
t.data_default = function( p ) {
// DEFINE DEFAULT DATA {
p.data_defaults = {
acftf: {
v: t.version,
},
p: {
o: {
uh: 0, // use header
},
ca: '', // caption content
},
// from data-colparam
c: [
{
c: '',
},
],
// header
h: [
{
c: '',
},
],
// body
b: [
[
{
c: '',
},
],
],
};
// MERGE DEFAULT DATA {
if ( p.data ) {
if ( typeof p.data.b === 'array' ) {
$.extend( true, p.data, p.data_defaults );
}
}
else {
p.data = p.data_defaults;
}
};
t.table_render = function( p ) {
// TABLE HTML MAIN {
p.obj_root.find( '.acf-table-wrap' ).remove();
p.obj_root.append( t.param.htmltable.table );
// TABLE GET OBJECTS {
p.obj_table = p.obj_root.find( '.acf-table-table' );
p.obj_top_row = p.obj_root.find( '.acf-table-top-row' ),
p.obj_top_insert = p.obj_top_row.find( '.acf-table-top-right' ),
p.obj_header_row = p.obj_root.find( '.<API key>' ),
p.obj_header_insert = p.obj_header_row.find( '.<API key>' ),
p.obj_bottom_row = p.obj_root.find( '.<API key>' ),
p.obj_bottom_insert = p.obj_bottom_row.find( '.<API key>' );
// TOP CELLS {
if ( p.data.c ) {
for ( i in p.data.c ) {
p.obj_top_insert.before( t.param.htmltable.top_cell );
}
}
t.table_top_labels( p );
// HEADER CELLS {
if ( p.data.h ) {
for ( i in p.data.h ) {
p.obj_header_insert.before( t.param.htmltable.header_cell.replace( '', p.data.h[ i ].c.replace( /xxx"/g, '"' ) ) );
}
}
// BODY ROWS {
if ( p.data.b ) {
for ( i in p.data.b ) {
p.obj_bottom_row.before( t.param.htmltable.body_row.replace( '', parseInt(i) + 1 ) );
}
}
// BODY ROWS CELLS {
var body_rows = p.obj_root.find( '.acf-table-body-row'),
row_i = 0;
if ( body_rows ) {
body_rows.each( function() {
var body_row = $( this ),
row_insert = body_row.find( '.<API key>' );
for( i in p.data.b[ row_i ] ) {
row_insert.before( t.param.htmltable.body_cell.replace( '', p.data.b[ row_i ][ i ].c.replace( /xxx"/g, '"' ) ) );
}
row_i = row_i + 1
} );
}
// TABLE BOTTOM {
if ( p.data.c ) {
for ( i in p.data.c ) {
p.obj_bottom_insert.before( t.param.htmltable.bottom_cell );
}
}
};
t.misc_render = function( p ) {
t.<API key>( p );
t.init_option_caption( p );
};
t.<API key> = function( p ) {
// VARS {
var v = {};
v.obj_use_header = p.obj_root.find( '.<API key>' );
// HEADER {
// HEADER: FIELD OPTIONS, THAT AFFECTS DATA {
// HEADER IS NOT ALLOWED
if ( p.field_options.use_header === 2 ) {
p.obj_table.addClass( '<API key>' );
p.data.p.o.uh = 0;
t.<API key>( p );
}
// HEADER IS REQUIRED
if ( p.field_options.use_header === 1 ) {
p.data.p.o.uh = 1;
t.<API key>( p );
}
// HEADER: SET CHECKBOX STATUS {
if ( p.data.p.o.uh === 1 ) {
v.obj_use_header.val( '1' );
}
if ( p.data.p.o.uh === 0 ) {
v.obj_use_header.val( '0' );
}
// HEADER: SET HEADER VISIBILITY {
if ( p.data.p.o.uh === 1 ) {
p.obj_table.removeClass( '<API key>' );
}
if ( p.data.p.o.uh === 0 ) {
p.obj_table.addClass( '<API key>' );
}
};
t.init_option_caption = function( p ) {
if (
typeof p.field_options.use_caption !== 'number' ||
p.field_options.use_caption === 2
) {
return;
}
// VARS {
var v = {};
v.obj_caption = p.obj_root.find( '.<API key>' );
// SET CAPTION VALUE {
v.obj_caption.val( p.data.p.ca );
};
t.table_add_col_event = function() {
t.obj.body.on( 'click', '.acf-table-add-col', function( e ) {
e.preventDefault();
var that = $( this ),
p = {};
p.obj_col = that.parent();
t.table_add_col( p );
} );
};
t.table_add_col = function( p ) {
// requires
// p.obj_col
var that_index = p.obj_col.index();
p.obj_root = p.obj_col.parents( '.acf-table-root' );
p.obj_table = p.obj_root.find( '.acf-table-table' );
$( p.obj_table.find( '.acf-table-top-row' ).children()[ that_index ] ).after( t.param.htmltable.top_cell.replace( '', '' ) );
$( p.obj_table.find( '.<API key>' ).children()[ that_index ] ).after( t.param.htmltable.header_cell.replace( '', '' ) );
p.obj_table.find( '.acf-table-body-row' ).each( function() {
$( $( this ).children()[ that_index ] ).after( t.param.htmltable.body_cell.replace( '', '' ) );
} );
$( p.obj_table.find( '.<API key>' ).children()[ that_index ] ).after( t.param.htmltable.bottom_cell.replace( '', '' ) );
t.table_top_labels( p );
p.obj_table.find( '.<API key>' ).show();
p.obj_table.find( '.<API key>' ).show();
t.table_build_json( p );
};
t.table_remove_col = function() {
t.obj.body.on( 'click', '.<API key>', function( e ) {
e.preventDefault();
var p = {},
that = $( this ),
that_index = that.parent().index(),
obj_rows = undefined,
cols_count = false;
p.obj_root = that.parents( '.acf-table-root' );
p.obj_table = p.obj_root.find( '.acf-table-table' );
p.obj_top = p.obj_root.find( '.acf-table-top-row' );
obj_rows = p.obj_table.find( '.acf-table-body-row' );
cols_count = p.obj_top.find( '.acf-table-top-cell' ).length;
$( p.obj_table.find( '.acf-table-top-row' ).children()[ that_index ] ).remove();
$( p.obj_table.find( '.<API key>' ).children()[ that_index ] ).remove();
if ( cols_count == 1 ) {
obj_rows.remove();
t.table_add_col( {
obj_col: p.obj_table.find( '.acf-table-top-left' )
} );
t.table_add_row( {
obj_row: p.obj_table.find( '.<API key>' )
} );
p.obj_table.find( '.<API key>' ).hide();
p.obj_table.find( '.<API key>' ).hide();
}
else {
obj_rows.each( function() {
$( $( this ).children()[ that_index ] ).remove();
} );
}
$( p.obj_table.find( '.<API key>' ).children()[ that_index ] ).remove();
t.table_top_labels( p );
t.table_build_json( p );
} );
};
t.table_add_row_event = function() {
t.obj.body.on( 'click', '.acf-table-add-row', function( e ) {
e.preventDefault();
var that = $( this ),
p = {};
p.obj_row = that.parent().parent();
t.table_add_row( p );
});
};
t.table_add_row = function( p ) {
// requires
// p.obj_row
var that_index = 0,
col_amount = 0,
body_cells_html = '';
p.obj_root = p.obj_row.parents( '.acf-table-root' );
p.obj_table = p.obj_root.find( '.acf-table-table' );
p.obj_table_rows = p.obj_table.children();
col_amount = p.obj_table.find( '.acf-table-top-cell' ).size();
that_index = p.obj_row.index();
for ( i = 0; i < col_amount; i++ ) {
body_cells_html = body_cells_html + t.param.htmltable.body_cell.replace( '', '' );
}
$( p.obj_table_rows[ that_index ] )
.after( t.param.htmltable.body_row )
.next()
.find('.acf-table-body-left')
.after( body_cells_html );
t.table_left_labels( p );
p.obj_table.find( '.<API key>' ).show();
p.obj_table.find( '.<API key>' ).show();
t.table_build_json( p );
};
t.table_remove_row = function() {
t.obj.body.on( 'click', '.<API key>', function( e ) {
e.preventDefault();
var p = {},
that = $( this ),
rows_count = false;
p.obj_root = that.parents( '.acf-table-root' );
p.obj_table = p.obj_root.find( '.acf-table-table' );
p.obj_rows = p.obj_root.find( '.acf-table-body-row' );
rows_count = p.obj_rows.length;
that.parent().parent().remove();
if ( rows_count == 1 ) {
t.table_add_row( {
obj_row: p.obj_table.find( '.<API key>' )
} );
p.obj_table.find( '.<API key>' ).hide();
}
t.table_left_labels( p );
t.table_build_json( p );
} );
};
t.table_top_labels = function( p ) {
var letter_i_1 = 'A'.charCodeAt( 0 ),
letter_i_2 = 'A'.charCodeAt( 0 ),
use_2 = false;
p.obj_table.find( '.acf-table-top-cont' ).each( function() {
var string = '';
if ( !use_2 ) {
string = String.fromCharCode( letter_i_1 );
if ( letter_i_1 === 'Z'.charCodeAt( 0 ) ) {
letter_i_1 = 'A'.charCodeAt( 0 );
use_2 = true;
}
else {
letter_i_1 = letter_i_1 + 1;
}
}
else {
string = String.fromCharCode( letter_i_1 ) + String.fromCharCode( letter_i_2 );
if ( letter_i_2 === 'Z'.charCodeAt( 0 ) ) {
letter_i_1 = letter_i_1 + 1;
letter_i_2 = 'A'.charCodeAt( 0 );
}
else {
letter_i_2 = letter_i_2 + 1;
}
}
$( this ).text( string );
} );
};
t.table_left_labels = function( p ) {
var i = 0;
p.obj_table.find( '.acf-table-body-left' ).each( function() {
i = i + 1;
$( this ).find( '.acf-table-body-cont' ).text( i );
} );
};
t.table_build_json = function( p ) {
var i = 0,
i2 = 0;
p.data = t.data_get( p );
t.data_default( p );
p.data.c = [];
p.data.h = [];
p.data.b = [];
// TOP {
i = 0;
p.obj_table.find( '.acf-table-top-cont' ).each( function() {
p.data.c[ i ] = {};
p.data.c[ i ].p = $( this ).parent().data( 'colparam' );
i = i + 1;
} );
// HEADER {
i = 0;
p.obj_table.find( '.<API key>' ).each( function() {
p.data.h[ i ] = {};
p.data.h[ i ].c = $( this ).html();
i = i + 1;
} );
// BODY {
i = 0;
i2 = 0;
p.obj_table.find( '.acf-table-body-row' ).each( function() {
p.data.b[ i ] = [];
$( this ).find( '.acf-table-body-cell .acf-table-body-cont' ).each( function() {
p.data.b[ i ][ i2 ] = {};
p.data.b[ i ][ i2 ].c = $( this ).html();
i2 = i2 + 1;
} );
i2 = 0;
i = i + 1;
} );
// UPDATE INPUT WITH NEW DATA {
t.<API key>( p );
};
t.<API key> = function( p ) {
// UPDATE INPUT WITH NEW DATA {
p.data = t.<API key>( p.data );
// makes json string from data object
var data = JSON.stringify( p.data );
// adds backslash to all \" in JSON string because encodeURIComponent() strippes backslashes
data.replace( /\\"/g, '\\"' );
// encodes the JSON string to URI component, the format, the JSON string is saved to the database
data = encodeURIComponent( data )
p.obj_root.find( 'input.table' ).val( data );
t.field_changed( p );
};
t.<API key> = function( data ) {
if ( typeof data.acftf === 'undefined' ) {
data.acftf = {};
}
data.acftf.v = t.version;
return data;
}
t.cell_editor = function() {
t.obj.body.on( 'click', '.acf-table-body-cell, .<API key>', function( e ) {
e.<API key>();
t.cell_editor_save();
var that = $( this );
t.<API key>({
'that': that
});
} );
t.obj.body.on( 'click', '.<API key>', function( e ) {
e.<API key>();
} );
t.obj.body.on( 'click', function( e ) {
t.cell_editor_save();
} );
};
t.<API key> = function( p ) {
var defaults = {
'that': false
};
p = $.extend( true, defaults, p );
if ( p['that'] ) {
var that_val = p['that'].find( '.acf-table-body-cont, .<API key>' ).html();
t.state.current_cell_obj = p['that'];
t.state.cell_editor_is_open = true;
p['that'].prepend( t.param.htmleditor ).find( '.<API key>' ).html( that_val ).focus();
}
};
t.get_next_table_cell = function( p ) {
var defaults = {
'key': false
};
p = $.extend( true, defaults, p );
// next cell of current row
var next_cell = t.state.current_cell_obj
.next( '.acf-table-body-cell, .<API key>' );
// else if get next row
if ( next_cell.length === 0 ) {
next_cell = t.state.current_cell_obj
.parent()
.next( '.acf-table-body-row' )
.find( '.acf-table-body-cell')
.first();
}
// if next row, get first cell of that row
if ( next_cell.length !== 0 ) {
t.state.current_cell_obj = next_cell;
}
else {
t.state.current_cell_obj = false;
}
};
t.get_prev_table_cell = function( p ) {
var defaults = {
'key': false
};
p = $.extend( true, defaults, p );
// prev cell of current row
var table_obj = t.state.current_cell_obj.closest( '.acf-table-table' ),
no_header = table_obj.hasClass( '<API key>' );
prev_cell = t.state.current_cell_obj
.prev( '.acf-table-body-cell, .<API key>' );
// else if get prev row
if ( prev_cell.length === 0 ) {
var row_selectors = [ '.acf-table-body-row' ];
// prevents going to header cell if table header is hidden
if ( no_header === false ) {
row_selectors.push( '.<API key>' );
}
prev_cell = t.state.current_cell_obj
.parent()
.prev( row_selectors.join( ',' ) )
.find( '.acf-table-body-cell, .<API key>' )
.last();
}
// if next row, get first cell of that row
if ( prev_cell.length !== 0 ) {
t.state.current_cell_obj = prev_cell;
}
else {
t.state.current_cell_obj = false;
}
};
t.cell_editor_save = function() {
var cell_editor = t.obj.body.find( '.<API key>' ),
<API key> = cell_editor.find( '.<API key>' ),
p = {},
cell_editor_val = '';
if ( typeof <API key>.val() !== 'undefined' ) {
p.obj_root = cell_editor.parents( '.acf-table-root' );
p.obj_table = p.obj_root.find( '.acf-table-table' );
var cell_editor_val = <API key>.val();
// prevent XSS injection
cell_editor_val = cell_editor_val.replace( /\<(script)/ig, '<$1' );
cell_editor_val = cell_editor_val.replace( /\<\/(script)/ig, '</$1' );
cell_editor.next().html( cell_editor_val );
t.table_build_json( p );
cell_editor.remove();
t.state.cell_editor_is_open = false;
p.obj_root.find( '.<API key>' ).show(),
p.obj_root.find( '.<API key>' ).show();
}
};
t.<API key> = function() {
t.obj.body.on( 'keydown', '.<API key>', function( e ) {
var keyCode = e.keyCode || e.which;
if ( keyCode == 9 ) {
e.preventDefault();
t.cell_editor_save();
if ( t.state.<API key> === 16 ) {
t.get_prev_table_cell();
}
else {
t.get_next_table_cell();
}
t.<API key>({
'that': t.state.current_cell_obj
});
}
t.state.<API key> = keyCode;
});
};
t.prevent_cell_links = function() {
t.obj.body.on( 'click', '.acf-table-body-cont a, .<API key> a', function( e ) {
e.preventDefault();
} );
};
t.sortable_fix_width = function(e, ui) {
ui.children().each( function() {
var that = $( this );
that.width( that.width() );
} );
return ui;
};
t.sortable_row = function() {
var param = {
axis: 'y',
items: '> .acf-table-body-row',
containment: 'parent',
handle: '.acf-table-body-left',
helper: t.sortable_fix_width,
update: function( event, ui ) {
var p = {};
p.obj_root = ui.item.parents( '.acf-table-root' );
p.obj_table = p.obj_root.find( '.acf-table-table' );
t.table_left_labels( p );
t.table_build_json( p );
},
};
$( '.acf-table-table' ).sortable( param );
};
t.sortable_col = function() {
var p = {};
p.start_index = 0;
p.end_index = 0;
var param = {
axis: 'x',
items: '> .acf-table-top-cell',
containment: 'parent',
helper: t.sortable_fix_width,
start: function(event, ui) {
p.start_index = ui.item.index();
},
update: function( event, ui ) {
p.end_index = ui.item.index();
p.obj_root = ui.item.parents( '.acf-table-root' );
p.obj_table = p.obj_root.find( '.acf-table-table' );
t.table_top_labels( p );
t.sort_cols( p );
t.table_build_json( p );
},
};
$( '.acf-table-top-row' ).sortable( param );
t.obj.body.on( 'click', '.acf-fc-popup', function() {
$( '.acf-table-top-row' )
.sortable('destroy')
.unbind();
window.setTimeout( function() {
$( '.acf-table-top-row' ).sortable( param );
}, 300 );
} );
};
t.field_changed = function( p ) {
if ( p.field_context === 'block' ) {
p.obj_root.change();
}
};
t.sort_cols = function( p ) {
p.obj_table.find('.<API key>').each( function() {
p.header_row = $(this),
p.header_row_children = p.header_row.children();
if ( p.end_index < p.start_index ) {
$( p.header_row_children[ p.end_index ] ).before( $( p.header_row_children[ p.start_index ] ) );
}
if ( p.end_index > p.start_index ) {
$( p.header_row_children[ p.end_index ] ).after( $( p.header_row_children[ p.start_index ] ) );
}
} );
p.obj_table.find('.acf-table-body-row').each( function() {
p.body_row = $(this),
p.body_row_children = p.body_row.children();
if ( p.end_index < p.start_index ) {
$( p.body_row_children[ p.end_index ] ).before( $( p.body_row_children[ p.start_index ] ) );
}
if ( p.end_index > p.start_index ) {
$( p.body_row_children[ p.end_index ] ).after( $( p.body_row_children[ p.start_index ] ) );
}
} );
};
t.helper = {
getLength: function( o ) {
var len = o.length ? --o.length : -1;
for (var k in o) {
len++;
}
return len;
},
};
};
var acf_table_field = new ACFTableField();
acf_table_field.init();
})( jQuery );
|
FROM kucing/node:latest
MAINTAINER Ivan <ivan@marsud.id>
RUN npm install -g bower gulp phantomjs eslint node-gyp
WORKDIR /app
|
/*
* Rather than call it "n64_types.h" or "my_stdint.h", the idea is that this
* header should be maintainable to any independent implementation's needs,
* especially in the event that one decides that type requirements should be
* mandated by the user and not permanently merged into the C specifications.
*
* Compilers always have had, always should have, and always will have the
* right to choose whether it is the programmer's job to establish the
* arbitrary sizes they prefer to have or whether the C language should
* be complicated enough to specify additional built-in criteria such as
* this, such that it should be able to depend on a system header for it.
*/
#ifndef _MY_TYPES_H_
#define _MY_TYPES_H_
/*
* Until proven otherwise, there are no standard integer types.
*/
#undef <API key>
/*
* an optional facility which could be used as an external alternative to
* deducing minimum-width types (if the compiler agrees to rely on this level
* of the language specifications to have it)
*
* Because no standard system is required to have any exact-width type, the
* C99 enforcement of <stdint.h> is more of an early initiative (as in,
* "better early than late" or "better early than never at all") rather than
* a fully portable resource available or even possible all of the time.
*/
#if defined(__STDC_VERSION__) && (__STDC_VERSION__ < 199901L)
/*
* Something which strictly emphasizes pre-C99 standard compliance likely
* does not have any <stdint.h> that we could include (nor built-in types).
*/
#elif defined(_XBOX) || defined(_XENON)
/*
* Since the Microsoft APIs frequently use `long` instead of `int` to ensure
* a minimum of 32-bit DWORD size, they were forced to propose a "LLP64" ABI.
*/
#define MICROSOFT_ABI
#elif defined(_MSC_VER) && (_MSC_VER < 1600)
/*
* In some better, older versions of MSVC, there often was no <stdint.h>.
* We can still use the built-in MSVC types to create the <stdint.h> types.
*/
#define MICROSOFT_ABI
#else
#include <stdint.h>
#endif
/*
* With or without external or internal support for <stdint.h>, we need to
* confirm the level of support for RCP data types on the Nintendo 64.
*
* We only need minimum-width data types, not exact-width types.
* Systems on which there is no 16- or 32-bit type, for example, can easily
* be accounted for by the code itself using optimizable AND bit-masks.
*/
#if defined(INT8_MIN) && defined(INT8_MAX)
#define HAVE_INT8_EXACT
#endif
#if defined(INT_FAST8_MIN) && defined(INT_FAST8_MAX)
#define HAVE_INT8_FAST
#endif
#if defined(INT_LEAST8_MIN) && defined(INT_LEAST8_MAX)
#define HAVE_INT8_MINIMUM
#endif
#if defined(INT16_MIN) && defined(INT16_MAX)
#define HAVE_INT16_EXACT
#endif
#if defined(INT_FAST16_MIN) && defined(INT_FAST16_MAX)
#define HAVE_INT16_FAST
#endif
#if defined(INT_LEAST16_MIN) && defined(INT_LEAST16_MAX)
#define HAVE_INT16_MINIMUM
#endif
#if defined(INT32_MIN) && defined(INT32_MAX)
#define HAVE_INT32_EXACT
#endif
#if defined(INT_FAST32_MIN) && defined(INT_FAST32_MAX)
#define HAVE_INT32_FAST
#endif
#if defined(INT_LEAST32_MIN) && defined(INT_LEAST32_MAX)
#define HAVE_INT32_MINIMUM
#endif
#if defined(INT64_MIN) && defined(INT64_MAX)
#define HAVE_INT64_EXACT
#endif
#if defined(INT_FAST64_MIN) && defined(INT_FAST64_MAX)
#define HAVE_INT64_FAST
#endif
#if defined(INT_LEAST64_MIN) && defined(INT_LEAST64_MAX)
#define HAVE_INT64_MINIMUM
#endif
#if defined(HAVE_INT8_EXACT)\
|| defined(HAVE_INT8_FAST) \
|| defined(HAVE_INT8_MINIMUM)
#define HAVE_INT8
#endif
#if defined(HAVE_INT16_EXACT)\
|| defined(HAVE_INT16_FAST) \
|| defined(HAVE_INT16_MINIMUM)
#define HAVE_INT16
#endif
#if defined(HAVE_INT32_EXACT)\
|| defined(HAVE_INT32_FAST) \
|| defined(HAVE_INT32_MINIMUM)
#define HAVE_INT32
#endif
#if defined(HAVE_INT64_EXACT)\
|| defined(HAVE_INT64_FAST) \
|| defined(HAVE_INT64_MINIMUM)
#define HAVE_INT64
#endif
/*
* This determines whether or not it is possible to use the evolution of the
* C standards for compiler advice on how to define the types or whether we
* will instead rely on preprocessor logic and ABI detection or C89 rules to
* define each of the types.
*/
#if defined(HAVE_INT8) \
&& defined(HAVE_INT16)\
&& defined(HAVE_INT32)\
&& defined(HAVE_INT64)
#define <API key>
#endif
#if defined(HAVE_INT8_EXACT)
typedef int8_t s8;
typedef uint8_t u8;
typedef s8 i8;
#elif defined(HAVE_INT8_FAST)
typedef int_fast8_t s8;
typedef uint_fast8_t u8;
typedef s8 i8;
#elif defined(HAVE_INT8_MINIMUM)
typedef int_least8_t s8;
typedef uint_least8_t u8;
typedef s8 i8;
#elif defined(MICROSOFT_ABI)
typedef signed __int8 s8;
typedef unsigned __int8 u8;
typedef __int8 i8;
#else
typedef signed char s8;
typedef unsigned char u8;
typedef char i8;
#endif
#if defined(HAVE_INT16_EXACT)
typedef int16_t s16;
typedef uint16_t u16;
#elif defined(HAVE_INT16_FAST)
typedef int_fast16_t s16;
typedef uint_fast16_t u16;
#elif defined(HAVE_INT16_MINIMUM)
typedef int_least16_t s16;
typedef uint_least16_t u16;
#elif defined(MICROSOFT_ABI)
typedef signed __int16 s16;
typedef unsigned __int16 u16;
#else
typedef signed short s16;
typedef unsigned short u16;
#endif
#if defined(HAVE_INT32_EXACT)
typedef int32_t s32;
typedef uint32_t u32;
#elif defined(HAVE_INT32_FAST)
typedef int_fast32_t s32;
typedef uint_fast32_t u32;
#elif defined(HAVE_INT32_MINIMUM)
typedef int_least32_t s32;
typedef uint_least32_t u32;
#elif defined(MICROSOFT_ABI)
typedef signed __int32 s32;
typedef unsigned __int32 u32;
#elif !defined(__LP64__) && (0xFFFFFFFFL < 0xFFFFFFFFUL)
typedef signed long s32;
typedef unsigned long u32;
#else
typedef signed int s32;
typedef unsigned int u32;
#endif
#if defined(HAVE_INT64_EXACT)
typedef int64_t s64;
typedef uint64_t u64;
#elif defined(HAVE_INT64_FAST)
typedef int_fast64_t s64;
typedef uint_fast64_t u64;
#elif defined(HAVE_INT64_MINIMUM)
typedef int_least64_t s64;
typedef uint_least64_t u64;
#elif defined(MICROSOFT_ABI)
typedef signed __int64 s64;
typedef unsigned __int64 u64;
#elif defined(__LP64__) && (<API key> < ~0UL)
typedef signed long s64;
typedef unsigned long u64;
#else
typedef signed long long s64;
typedef unsigned long long u64;
#endif
/*
* Although most types are signed by default, using `int' instead of `signed
* int' and `i32' instead of `s32' can be preferable to denote cases where
* the signedness of something operated on is irrelevant to the algorithm.
*/
typedef s16 i16;
typedef s32 i32;
typedef s64 i64;
/*
* If <stdint.h> was unavailable or not included (should be included before
* "my_types.h" if it is ever to be included), then perhaps this is the
* right opportunity to try defining the <stdint.h> types ourselves.
*
* Due to sole popularity, code can sometimes be easier to read when saying
* things like "int8_t" instead of "i8", just because more people are more
* likely to understand the <stdint.h> type names in generic C code. To be
* as neutral as possible, people will have every right to sometimes prefer
* saying "uint32_t" instead of "u32" for the sake of modern standards.
*
* The below macro just means whether or not we had access to <stdint.h>
* material to deduce any of our 8-, 16-, 32-, or 64-bit type definitions.
*/
#ifndef <API key>
typedef s8 int8_t;
typedef u8 uint8_t;
typedef s16 int16_t;
typedef u16 uint16_t;
typedef s32 int32_t;
typedef u32 uint32_t;
typedef s64 int64_t;
typedef u64 uint64_t;
#define <API key>
#endif
/*
* Single- and double-precision floating-point data types have a little less
* room for maintenance across different CPU processors, as the C standard
* just provides `float' and `[long] double'. However, if we are going to
* need 32- and 64-bit floating-point precision (which MIPS emulation does
* require), then it could be nice to have these names just to be consistent.
*/
typedef float f32;
typedef double f64;
/*
* Pointer types, serving as the memory reference address to the actual type.
* I thought this was useful to have due to the various reasons for declaring
* or using variable pointers in various styles and complex scenarios.
* ex) i32* pointer;
* ex) i32 * pointer;
* ex) i32 *a, *b, *c;
* neutral: `pi32 pointer;' or `pi32 a, b, c;'
*/
typedef i8* pi8;
typedef i16* pi16;
typedef i32* pi32;
typedef i64* pi64;
typedef s8* ps8;
typedef s16* ps16;
typedef s32* ps32;
typedef s64* ps64;
typedef u8* pu8;
typedef u16* pu16;
typedef u32* pu32;
typedef u64* pu64;
typedef f32* pf32;
typedef f64* pf64;
typedef void* p_void;
typedef void(*p_func)(void);
/*
* helper macros with exporting functions for shared objects or dynamically
* loaded libraries
*/
#if defined(_XBOX)
#define EXPORT
#define CALL
#elif defined(_WIN32)
#define EXPORT __declspec(dllexport)
#define CALL __cdecl
#elif (__GNUC__)
#define EXPORT __attribute__((visibility("default")))
#define CALL
#endif
/*
* Optimizing compilers aren't necessarily perfect compilers, but they do
* have that extra chance of supporting explicit [anti-]inline instructions.
*/
#ifdef _MSC_VER
#define INLINE __inline
#define NOINLINE __declspec(noinline)
#define ALIGNED _declspec(align(16))
#elif defined(__GNUC__)
#define INLINE inline
#define NOINLINE __attribute__((noinline))
#define ALIGNED __attribute__((aligned(16)))
#else
#define INLINE
#define NOINLINE
#define ALIGNED
#endif
/*
* aliasing helpers
* Strictly put, this may be unspecified behavior, but it's nice to have!
*/
typedef union {
u8 B[2];
s8 SB[2];
i16 W;
u16 UW;
s16 SW; /* Here, again, explicitly writing "signed" may help clarity. */
} word_16;
typedef union {
u8 B[4];
s8 SB[4];
i16 H[2];
u16 UH[2];
s16 SH[2];
i32 W;
u32 UW;
s32 SW;
} word_32;
typedef union {
u8 B[8];
s8 SB[8];
i16 F[4];
u16 UF[4];
s16 SF[4];
i32 H[2];
u32 UH[2];
s32 SH[2];
i64 W;
u64 UW;
s64 SW;
} word_64;
/*
* helper macros for indexing memory in the above unions
* EEP! Currently concentrates mostly on 32-bit endianness.
*/
#ifndef ENDIAN_M
#if defined(__BIG_ENDIAN__) | (__BYTE_ORDER != __LITTLE_ENDIAN)
#define ENDIAN_M ( 0)
#else
#define ENDIAN_M (~0)
#endif
#endif
#define ENDIAN_SWAP_BYTE (ENDIAN_M & 0x7 & 3)
#define ENDIAN_SWAP_HALF (ENDIAN_M & 0x6 & 2)
#define ENDIAN_SWAP_BIMI (ENDIAN_M & 0x5 & 1)
#define ENDIAN_SWAP_WORD (ENDIAN_M & 0x4 & 0)
#define BES(address) ((address) ^ ENDIAN_SWAP_BYTE)
#define HES(address) ((address) ^ ENDIAN_SWAP_HALF)
#define MES(address) ((address) ^ ENDIAN_SWAP_BIMI)
#define WES(address) ((address) ^ ENDIAN_SWAP_WORD)
/*
* extra types of encoding for the well-known MIPS RISC architecture
* Possibly implement other machine types in future versions of this header.
*/
typedef struct {
unsigned opcode: 6;
unsigned rs: 5;
unsigned rt: 5;
unsigned rd: 5;
unsigned sa: 5;
unsigned function: 6;
} MIPS_type_R;
typedef struct {
unsigned opcode: 6;
unsigned rs: 5;
unsigned rt: 5;
unsigned imm: 16;
} MIPS_type_I;
/*
* Maybe worth including, maybe not.
* It's sketchy since bit-fields pertain to `int' type, of which the size is
* not necessarily going to be even 4 bytes. On C compilers for MIPS itself,
* almost certainly, but is this really important to have?
*/
#if 0
typedef struct {
unsigned opcode: 6;
unsigned target: 26;
} MIPS_type_J;
#endif
/*
* Saying "int" all the time for variables of true/false meaning can be sort
* of misleading. (So can adding dumb features to C99, like "bool".)
*
* Boolean is a proper noun, so the correct name has a capital 'B'.
*/
typedef int Boolean;
#if !defined(FALSE) && !defined(TRUE)
#define FALSE 0
#define TRUE 1
#endif
#endif
|
package de.sauriel.rasengan.ui;
import java.awt.BorderLayout;
import javax.swing.JDialog;
import javax.swing.JProgressBar;
import javax.swing.JLabel;
import java.util.Observable;
import java.util.Observer;
public class DownloadDialog extends JDialog implements Observer {
private static final long serialVersionUID = <API key>;
JProgressBar progressBar;
public DownloadDialog() {
// Configure Dialog
<API key>(JDialog.DO_NOTHING_ON_CLOSE);
setAlwaysOnTop(true);
setModal(true);
setModalityType(ModalityType.MODELESS);
setResizable(false);
setTitle("Downloading: " + RasenganMainFrame.comic.getName());
setBounds(100, 100, 300, 60);
setLayout(new BorderLayout(0, 0));
// Set Content
JLabel labelDownload = new JLabel("Downloading: " + RasenganMainFrame.comic.getName());
add(labelDownload, BorderLayout.NORTH);
progressBar = new JProgressBar();
add(progressBar, BorderLayout.CENTER);
}
@Override
public void update(Observable comicService, Object imagesCount) {
int[] newImagesCount= (int[]) imagesCount;
progressBar.setMaximum(newImagesCount[1]);
progressBar.setValue(newImagesCount[0]);
if (newImagesCount[0] == newImagesCount[1]) {
dispose();
}
}
}
|
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
#ifndef __PAGE_MASTER_H__
#define __PAGE_MASTER_H__
#include <nm-connection.h>
#include <glib.h>
#include <glib-object.h>
#include "ce-page.h"
#include "connection-helpers.h"
#define CE_TYPE_PAGE_MASTER (<API key> ())
#define CE_PAGE_MASTER(obj) (<API key> ((obj), CE_TYPE_PAGE_MASTER, CEPageMaster))
#define <API key>(klass) (<API key> ((klass), CE_TYPE_PAGE_MASTER, CEPageMasterClass))
#define CE_IS_PAGE_MASTER(obj) (<API key> ((obj), CE_TYPE_PAGE_MASTER))
#define <API key>(klass) (<API key> ((klass), CE_TYPE_PAGE_MASTER))
#define <API key>(obj) (<API key> ((obj), CE_TYPE_PAGE_MASTER, CEPageMasterClass))
typedef struct {
CEPage parent;
gboolean aggregating;
} CEPageMaster;
typedef struct {
CEPageClass parent;
/* signals */
void (*create_connection) (CEPageMaster *self, NMConnection *connection);
void (*connection_added) (CEPageMaster *self, NMConnection *connection);
void (*connection_removed) (CEPageMaster *self, NMConnection *connection);
/* methods */
void (*add_slave) (CEPageMaster *self, <API key> result_func);
} CEPageMasterClass;
GType <API key> (void);
gboolean <API key> (CEPageMaster *self);
#endif /* __PAGE_MASTER_H__ */
|
/**
* App Control
*
* Central controller attached to the top level <html>
* element
*/
"use strict";
( function ( angular, app ) {
// get user profile data
app.controller( "AppCtrl", [ '$rootScope', '$scope', '$state', 'UserService',
function ( $rootScope, $scope, $state, UserService ) {
// bodyClass definitions
// in a larger project this would be abstracted to allow for multiple
// classes to easily be added or removed
// current state
$rootScope.$on( '$stateChangeStart',
function ( event, toState, toParams, fromState, fromParams ) {
var currentState = toState.name.replace( '.', '-' );
$scope.bodyClass = 'state-' + currentState;
}
);
/**
* Format Avatar
*/
$scope.currentUserAvatar = function ( src, size ) {
return UserService.<API key>( size );
};
}
] );
} )( angular, SimplySocial );
|
package org.openzal.zal.ldap;
import javax.annotation.Nonnull;
public class LdapServerType
{
@Nonnull
private final com.zimbra.cs.ldap.LdapServerType mLdapServerType;
public final static LdapServerType MASTER = new LdapServerType(com.zimbra.cs.ldap.LdapServerType.MASTER);
public final static LdapServerType REPLICA = new LdapServerType(com.zimbra.cs.ldap.LdapServerType.REPLICA);
public LdapServerType(@Nonnull Object ldapServerType)
{
mLdapServerType = (com.zimbra.cs.ldap.LdapServerType)ldapServerType;
}
protected <T> T toZimbra(Class<T> cls)
{
return cls.cast(mLdapServerType);
}
public boolean isMaster() {
return mLdapServerType.isMaster();
}
}
|
package Opsview::Schema::Useragents;
use strict;
use warnings;
use base 'Opsview::DBIx::Class';
__PACKAGE__->load_components(qw/InflateColumn::DateTime Core/);
__PACKAGE__->table( __PACKAGE__->opsviewdb . ".useragents" );
__PACKAGE__->add_columns(
"id",
{
data_type => "VARCHAR",
default_value => undef,
is_nullable => 0,
size => 255
},
"last_update",
{
data_type => "DATETIME",
timezone => "UTC",
default_value => undef,
is_nullable => 0
}
);
__PACKAGE__->set_primary_key( "id" );
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:24E+L+rBEoeFJ5x/7Y4nUQ
# AUTHORS:
# This file is part of Opsview
# Opsview is free software; you can redistribute it and/or modify
# (at your option) any later version.
# Opsview is distributed in the hope that it will be useful,
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# along with Opsview; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
# You can replace this text with custom content, and it will be preserved on regeneration
1;
|
'use strict';
/**
* @ngdoc function
* @name quickNewsApp.controller:CbcCtrl
* @description
* # CbcCtrl
* Controller of the quickNewsApp
*/
angular.module('quickNewsApp')
.controller('CbcCtrl', function ($scope, $http) {
this.awesomeThings = [
'HTML5 Boilerplate',
'AngularJS',
'Karma'
];
$scope.postLimit = 10;
$scope.showMorePosts = function() {
$scope.postLimit += 5;
};
$scope.isSet = function(checkTab) {
return this.tab === checkTab;
};
$scope.setTab = function(activeTab) {
this.tab = activeTab;
$scope.postLimit = 10;
$scope.getFeed(activeTab);
};
$scope.getActiveTab = function() {
return this.tab;
};
$scope.getFeed = function(category) {
/*jshint unused: false */
$scope.loading = true;
var url = '//quicknews.amanuppal.ca:5000/cbc?url=' + category;
$http.get(url)
.success(function(data, status, headers, config) {
$scope.entries = data.items;
console.log($scope.entries);
$scope.numEntries = Object.keys($scope.entries).length;
$scope.loading = false;
})
.error(function(data, status, headers, config) {
console.log('Error loading feed: ' + url + ', status: ' + status);
});
};
});
|
package org.hectordam.proyectohector;
import java.util.ArrayList;
import org.hectordam.proyectohector.R;
import org.hectordam.proyectohector.base.Bar;
import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.<API key>;
import com.google.android.gms.common.<API key>.ConnectionCallbacks;
import com.google.android.gms.common.<API key>.<API key>;
import com.google.android.gms.location.LocationClient;
import com.google.android.gms.location.LocationListener;
import com.google.android.gms.location.LocationRequest;
import com.google.android.gms.maps.GoogleMap;
import com.google.android.gms.maps.CameraUpdate;
import com.google.android.gms.maps.CameraUpdateFactory;
import com.google.android.gms.maps.MapsInitializer;
import com.google.android.gms.maps.SupportMapFragment;
import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.maps.model.MarkerOptions;
import android.location.Location;
import android.os.Bundle;
import android.support.v4.app.FragmentActivity;
import android.view.Menu;
public class Mapa extends FragmentActivity implements LocationListener,ConnectionCallbacks, <API key>{
private GoogleMap mapa;
private LocationClient locationClient;
private CameraUpdate camara;
private static final LocationRequest LOC_REQUEST = LocationRequest.create()
.setInterval(5000)
.setFastestInterval(16)
.setPriority(LocationRequest.<API key>);
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.mapa);
try {
MapsInitializer.initialize(this);
} catch (<API key> e) {
e.printStackTrace();
}
mapa = ((SupportMapFragment) <API key>().findFragmentById(R.id.map)).getMap();
ArrayList<Bar> bares = getIntent().<API key>("bares");
if (bares != null) {
//marcarBares(bares);
}
mapa.<API key>(true);
<API key>();
camara = CameraUpdateFactory.newLatLng(new LatLng(41.6561, -0.8773));
mapa.moveCamera(camara);
mapa.animateCamera(CameraUpdateFactory.zoomTo(11.0f), 2000, null);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.mapa, menu);
return true;
}
private void marcarBares(ArrayList<Bar> bares) {
if (bares.size() > 0) {
for (Bar bar : bares) {
mapa.addMarker(new MarkerOptions()
.position(new LatLng(bar.getLatitud(), bar.getLongitud()))
.title(bar.getNombre()));
}
}
}
/**
* Se muestra la Activity
*/
@Override
protected void onStart() {
super.onStart();
locationClient.connect();
}
@Override
protected void onStop() {
super.onStop();
locationClient.disconnect();
}
private void <API key>() {
if (locationClient == null) {
locationClient = new LocationClient(this, this, this);
}
}
@Override
public void onConnected(Bundle arg0) {
locationClient.<API key>(LOC_REQUEST, this);
}
@Override
public void onConnectionFailed(ConnectionResult arg0) {
}
@Override
public void onDisconnected() {
}
@Override
public void onLocationChanged(Location arg0) {
}
}
|
#define DEBUG
/* #define VERBOSE_DEBUG */
/*#define SEC_TSP_DEBUG*/
/* #define <API key> */
/* #define FORCE_FW_FLASH */
/* #define FORCE_FW_PASS */
/* #define ESD_DEBUG */
#define <API key>
#define SEC_TSP_FW_UPDATE
#define TSP_BUF_SIZE 1024
#define FAIL -1
#include <linux/delay.h>
#include <linux/earlysuspend.h>
#include <linux/firmware.h>
#include <linux/gpio.h>
#include <linux/i2c.h>
#include <linux/init.h>
#include <linux/input.h>
#include <linux/input/mt.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <mach/gpio.h>
#include <linux/uaccess.h>
#include <mach/cpufreq.h>
#include <mach/dev.h>
#include <linux/platform_data/mms_ts.h>
#include <asm/unaligned.h>
#define MAX_FINGERS 10
#define MAX_WIDTH 30
#define MAX_PRESSURE 255
#define MAX_ANGLE 90
#define MIN_ANGLE -90
/* Registers */
#define MMS_MODE_CONTROL 0x01
#define MMS_XYRES_HI 0x02
#define MMS_XRES_LO 0x03
#define MMS_YRES_LO 0x04
#define <API key> 0x0F
#define MMS_INPUT_EVENT0 0x10
#define FINGER_EVENT_SZ 8
#define MMS_TSP_REVISION 0xF0
#define MMS_HW_REVISION 0xF1
#define MMS_COMPAT_GROUP 0xF2
#define MMS_FW_VERSION 0xF3
enum {
<API key> = 0x59F3,
<API key> = 0x62CD,
ISP_MODE_FLASH_READ = 0x6AC9,
};
/* each address addresses 4-byte words */
#define ISP_MAX_FW_SIZE (0x1F00 * 4)
#define ISP_IC_INFO_ADDR 0x1F00
#ifdef SEC_TSP_FW_UPDATE
#define WORD_SIZE 4
#define ISC_PKT_SIZE 1029
#define ISC_PKT_DATA_SIZE 1024
#define ISC_PKT_HEADER_SIZE 3
#define ISC_PKT_NUM 31
#define ISC_ENTER_ISC_CMD 0x5F
#define ISC_ENTER_ISC_DATA 0x01
#define ISC_CMD 0xAE
#define <API key> 0x55
#define <API key> 9
#define <API key> 0xF1
#define <API key> 0x0F
#define <API key> 0xF0
#define <API key> 0xAF
#define ISC_CONFIRM_CRC 0x03
#define ISC_DEFAULT_CRC 0xFFFF
#endif
#ifdef <API key>
#define TX_NUM 26
#define RX_NUM 14
#define NODE_NUM 364 /* 26x14 */
/* VSC(Vender Specific Command) */
#define MMS_VSC_CMD 0xB0 /* vendor specific command */
#define MMS_VSC_MODE 0x1A /* mode of vendor */
#define MMS_VSC_CMD_ENTER 0X01
#define <API key> 0X02
#define MMS_VSC_CMD_CM_ABS 0X03
#define MMS_VSC_CMD_EXIT 0X05
#define <API key> 0X04
#define MMS_VSC_CMD_RAW 0X06
#define MMS_VSC_CMD_REFER 0X07
#define TSP_CMD_STR_LEN 32
#define <API key> 512
#define TSP_CMD_PARAM_NUM 8
#endif /* <API key> */
/* Touch booster */
#if defined(<API key>) &&\
defined(CONFIG_BUSFREQ_OPP)
#define TOUCH_BOOSTER 1
#define <API key> 100
#define <API key> 200
#else
#define TOUCH_BOOSTER 0
#endif
struct device *sec_touchscreen;
static struct device *bus_dev;
int touch_is_pressed = 0;
#define ISC_DL_MODE 1
/* 4.8" OCTA LCD */
#define FW_VERSION_4_8 0xBD
#define MAX_FW_PATH 255
#define TSP_FW_FILENAME "melfas_fw.bin"
#if ISC_DL_MODE /* ISC_DL_MODE start */
/*
* Default configuration of ISC mode
*/
#define DEFAULT_SLAVE_ADDR 0x48
#define SECTION_NUM 4
#define SECTION_NAME_LEN 5
#define PAGE_HEADER 3
#define PAGE_DATA 1024
#define PAGE_TAIL 2
#define PACKET_SIZE (PAGE_HEADER + PAGE_DATA + PAGE_TAIL)
#define TS_WRITE_REGS_LEN 1030
#define TIMEOUT_CNT 10
#define STRING_BUF_LEN 100
/* State Registers */
#define <API key> 0x01
#define ISC_ADDR_VERSION 0xE1
#define <API key> 0xE5
/* Config Update Commands */
#define ISC_CMD_ENTER_ISC 0x5F
#define <API key> 0x01
#define ISC_CMD_UPDATE_MODE 0xAE
#define <API key> 0x55
#define <API key> 0XF1
#define <API key> 0x0F
#define <API key> 0xF0
#define <API key> 0xAF
#define <API key> 0x01
#define <API key> 0x03
#define ISC_CHAR_2_BCD(num) (((num/10)<<4) + (num%10))
#define ISC_MAX(x, y) (((x) > (y)) ? (x) : (y))
static const char section_name[SECTION_NUM][SECTION_NAME_LEN] = {
"BOOT", "CORE", "PRIV", "PUBL"
};
static const unsigned char crc0_buf[31] = {
0x1D, 0x2C, 0x05, 0x34, 0x95, 0xA4, 0x8D, 0xBC,
0x59, 0x68, 0x41, 0x70, 0xD1, 0xE0, 0xC9, 0xF8,
0x3F, 0x0E, 0x27, 0x16, 0xB7, 0x86, 0xAF, 0x9E,
0x7B, 0x4A, 0x63, 0x52, 0xF3, 0xC2, 0xEB
};
static const unsigned char crc1_buf[31] = {
0x1E, 0x9C, 0xDF, 0x5D, 0x76, 0xF4, 0xB7, 0x35,
0x2A, 0xA8, 0xEB, 0x69, 0x42, 0xC0, 0x83, 0x01,
0x04, 0x86, 0xC5, 0x47, 0x6C, 0xEE, 0xAD, 0x2F,
0x30, 0xB2, 0xF1, 0x73, 0x58, 0xDA, 0x99
};
static tISCFWInfo_t mbin_info[SECTION_NUM];
static tISCFWInfo_t ts_info[SECTION_NUM]; /* read F/W version from IC */
static bool section_update_flag[SECTION_NUM];
const struct firmware *fw_mbin[SECTION_NUM];
static unsigned char g_wr_buf[1024 + 3 + 2];
#endif
enum fw_flash_mode {
ISP_FLASH,
ISC_FLASH,
};
enum {
BUILT_IN = 0,
UMS,
REQ_FW,
};
struct tsp_callbacks {
void (*inform_charger)(struct tsp_callbacks *tsp_cb, bool mode);
};
struct mms_ts_info {
struct i2c_client *client;
struct input_dev *input_dev;
char phys[32];
int max_x;
int max_y;
bool invert_x;
bool invert_y;
const u8 *config_fw_version;
int irq;
int (*power) (bool on);
struct <API key> *pdata;
struct early_suspend early_suspend;
/* protects the enabled flag */
struct mutex lock;
bool enabled;
void (*register_cb)(void *);
struct tsp_callbacks callbacks;
bool ta_status;
bool noise_mode;
unsigned char finger_state[MAX_FINGERS];
#if defined(SEC_TSP_FW_UPDATE)
u8 fw_update_state;
#endif
u8 fw_ic_ver;
enum fw_flash_mode fw_flash_mode;
#if TOUCH_BOOSTER
struct delayed_work work_dvfs_off;
struct delayed_work work_dvfs_chg;
bool dvfs_lock_status;
int cpufreq_level;
struct mutex dvfs_lock;
#endif
#if defined(<API key>)
struct list_head cmd_list_head;
u8 cmd_state;
char cmd[TSP_CMD_STR_LEN];
int cmd_param[TSP_CMD_PARAM_NUM];
char cmd_result[<API key>];
struct mutex cmd_lock;
bool cmd_is_running;
unsigned int reference[NODE_NUM];
unsigned int raw[NODE_NUM]; /* CM_ABS */
unsigned int inspection[NODE_NUM];/* CM_DELTA */
unsigned int intensity[NODE_NUM];
bool ft_flag;
#endif /* <API key> */
};
struct mms_fw_image {
__le32 hdr_len;
__le32 data_len;
__le32 fw_ver;
__le32 hdr_ver;
u8 data[0];
} __packed;
#ifdef <API key>
static void <API key>(struct early_suspend *h);
static void mms_ts_late_resume(struct early_suspend *h);
#endif
#if TOUCH_BOOSTER
static bool dvfs_lock_status = false;
static bool press_status = false;
#endif
#if defined(<API key>)
#define TSP_CMD(name, func) .cmd_name = name, .cmd_func = func
struct tsp_cmd {
struct list_head list;
const char *cmd_name;
void (*cmd_func)(void *device_data);
};
static void fw_update(void *device_data);
static void get_fw_ver_bin(void *device_data);
static void get_fw_ver_ic(void *device_data);
static void get_config_ver(void *device_data);
static void get_threshold(void *device_data);
static void module_off_master(void *device_data);
static void module_on_master(void *device_data);
static void module_off_slave(void *device_data);
static void module_on_slave(void *device_data);
static void get_chip_vendor(void *device_data);
static void get_chip_name(void *device_data);
static void get_reference(void *device_data);
static void get_cm_abs(void *device_data);
static void get_cm_delta(void *device_data);
static void get_intensity(void *device_data);
static void get_x_num(void *device_data);
static void get_y_num(void *device_data);
static void run_reference_read(void *device_data);
static void run_cm_abs_read(void *device_data);
static void run_cm_delta_read(void *device_data);
static void run_intensity_read(void *device_data);
static void not_support_cmd(void *device_data);
struct tsp_cmd tsp_cmds[] = {
{TSP_CMD("fw_update", fw_update),},
{TSP_CMD("get_fw_ver_bin", get_fw_ver_bin),},
{TSP_CMD("get_fw_ver_ic", get_fw_ver_ic),},
{TSP_CMD("get_config_ver", get_config_ver),},
{TSP_CMD("get_threshold", get_threshold),},
/* {TSP_CMD("module_off_master", module_off_master),},
{TSP_CMD("module_on_master", module_on_master),},
{TSP_CMD("module_off_slave", not_support_cmd),},
{TSP_CMD("module_on_slave", not_support_cmd),}, */
{TSP_CMD("get_chip_vendor", get_chip_vendor),},
{TSP_CMD("get_chip_name", get_chip_name),},
{TSP_CMD("get_x_num", get_x_num),},
{TSP_CMD("get_y_num", get_y_num),},
{TSP_CMD("get_reference", get_reference),},
{TSP_CMD("get_cm_abs", get_cm_abs),},
{TSP_CMD("get_cm_delta", get_cm_delta),},
{TSP_CMD("get_intensity", get_intensity),},
{TSP_CMD("run_reference_read", run_reference_read),},
{TSP_CMD("run_cm_abs_read", run_cm_abs_read),},
{TSP_CMD("run_cm_delta_read", run_cm_delta_read),},
{TSP_CMD("run_intensity_read", run_intensity_read),},
{TSP_CMD("not_support_cmd", not_support_cmd),},
};
#endif
#if TOUCH_BOOSTER
static void change_dvfs_lock(struct work_struct *work)
{
struct mms_ts_info *info = container_of(work,
struct mms_ts_info, work_dvfs_chg.work);
int ret;
mutex_lock(&info->dvfs_lock);
ret = dev_lock(bus_dev, sec_touchscreen, 267160); /* 266 Mhz setting */
if (ret < 0)
pr_err("%s: dev change bud lock failed(%d)\n",\
__func__, __LINE__);
else
pr_info("[TSP] change_dvfs_lock");
mutex_unlock(&info->dvfs_lock);
}
static void set_dvfs_off(struct work_struct *work)
{
struct mms_ts_info *info = container_of(work,
struct mms_ts_info, work_dvfs_off.work);
int ret;
mutex_lock(&info->dvfs_lock);
ret = dev_unlock(bus_dev, sec_touchscreen);
if (ret < 0)
pr_err("%s: dev unlock failed(%d)\n",
__func__, __LINE__);
<API key>(DVFS_LOCK_ID_TSP);
info->dvfs_lock_status = false;
pr_info("[TSP] DVFS Off!");
mutex_unlock(&info->dvfs_lock);
}
static void set_dvfs_lock(struct mms_ts_info *info, uint32_t on)
{
int ret;
mutex_lock(&info->dvfs_lock);
if (info->cpufreq_level <= 0) {
ret = <API key>(800000, &info->cpufreq_level);
if (ret < 0)
pr_err("[TSP] <API key> error");
goto out;
}
if (on == 0) {
if (info->dvfs_lock_status) {
cancel_delayed_work(&info->work_dvfs_chg);
<API key>(&info->work_dvfs_off,
msecs_to_jiffies(<API key>));
}
} else if (on == 1) {
cancel_delayed_work(&info->work_dvfs_off);
if (!info->dvfs_lock_status) {
ret = dev_lock(bus_dev, sec_touchscreen, 400200);
if (ret < 0) {
pr_err("%s: dev lock failed(%d)\n",\
__func__, __LINE__);
}
ret = exynos_cpufreq_lock(DVFS_LOCK_ID_TSP,
info->cpufreq_level);
if (ret < 0)
pr_err("%s: cpu lock failed(%d)\n",\
__func__, __LINE__);
<API key>(&info->work_dvfs_chg,
msecs_to_jiffies(<API key>));
info->dvfs_lock_status = true;
pr_info("[TSP] DVFS On![%d]", info->cpufreq_level);
}
} else if (on == 2) {
cancel_delayed_work(&info->work_dvfs_off);
cancel_delayed_work(&info->work_dvfs_chg);
schedule_work(&info->work_dvfs_off.work);
}
out:
mutex_unlock(&info->dvfs_lock);
}
#endif
static inline void mms_pwr_on_reset(struct mms_ts_info *info)
{
struct i2c_adapter *adapter = to_i2c_adapter(info->client->dev.parent);
if (!info->pdata->mux_fw_flash) {
dev_info(&info->client->dev,
"missing platform data, can't do power-on-reset\n");
return;
}
i2c_lock_adapter(adapter);
info->pdata->mux_fw_flash(true);
info->pdata->power(false);
<API key>(info->pdata->gpio_sda, 0);
<API key>(info->pdata->gpio_scl, 0);
<API key>(info->pdata->gpio_int, 0);
msleep(50);
info->pdata->power(true);
msleep(200);
info->pdata->mux_fw_flash(false);
i2c_unlock_adapter(adapter);
/* TODO: Seems long enough for the firmware to boot.
* Find the right value */
msleep(250);
}
static void release_all_fingers(struct mms_ts_info *info)
{
struct i2c_client *client = info->client;
int i;
pr_debug(KERN_DEBUG "[TSP] %s\n", __func__);
for (i = 0; i < MAX_FINGERS; i++) {
if (info->finger_state[i] == 1) {
dev_notice(&client->dev, "finger %d up(force)\n", i);
}
info->finger_state[i] = 0;
input_mt_slot(info->input_dev, i);
<API key>(info->input_dev, MT_TOOL_FINGER,
false);
}
input_sync(info->input_dev);
#if TOUCH_BOOSTER
set_dvfs_lock(info, 2);
pr_info("[TSP] dvfs_lock free.\n ");
#endif
}
static void mms_set_noise_mode(struct mms_ts_info *info)
{
struct i2c_client *client = info->client;
if (!(info->noise_mode && info->enabled))
return;
dev_notice(&client->dev, "%s\n", __func__);
if (info->ta_status) {
dev_notice(&client->dev, "noise_mode & TA connect!!!\n");
<API key>(info->client, 0x30, 0x1);
} else {
dev_notice(&client->dev, "noise_mode & TA disconnect!!!\n");
<API key>(info->client, 0x30, 0x2);
}
}
static void reset_mms_ts(struct mms_ts_info *info)
{
struct i2c_client *client = info->client;
if (info->enabled == false)
return;
dev_notice(&client->dev, "%s++\n", __func__);
disable_irq_nosync(info->irq);
info->enabled = false;
touch_is_pressed = 0;
release_all_fingers(info);
mms_pwr_on_reset(info);
enable_irq(info->irq);
info->enabled = true;
if (info->ta_status) {
dev_notice(&client->dev, "TA connect!!!\n");
<API key>(info->client, 0x33, 0x1);
} else {
dev_notice(&client->dev, "TA disconnect!!!\n");
<API key>(info->client, 0x33, 0x2);
}
mms_set_noise_mode(info);
dev_notice(&client->dev, "%s--\n", __func__);
}
static void melfas_ta_cb(struct tsp_callbacks *cb, bool ta_status)
{
struct mms_ts_info *info =
container_of(cb, struct mms_ts_info, callbacks);
struct i2c_client *client = info->client;
dev_notice(&client->dev, "%s\n", __func__);
info->ta_status = ta_status;
if (info->enabled) {
if (info->ta_status) {
dev_notice(&client->dev, "TA connect!!!\n");
<API key>(info->client, 0x33, 0x1);
} else {
dev_notice(&client->dev, "TA disconnect!!!\n");
<API key>(info->client, 0x33, 0x2);
}
mms_set_noise_mode(info);
}
}
static irqreturn_t mms_ts_interrupt(int irq, void *dev_id)
{
struct mms_ts_info *info = dev_id;
struct i2c_client *client = info->client;
u8 buf[MAX_FINGERS * FINGER_EVENT_SZ] = { 0 };
int ret;
int i;
int sz;
u8 reg = MMS_INPUT_EVENT0;
struct i2c_msg msg[] = {
{
.addr = client->addr,
.flags = 0,
.buf = ®,
.len = 1,
}, {
.addr = client->addr,
.flags = I2C_M_RD,
.buf = buf,
},
};
sz = <API key>(client, <API key>);
if (sz < 0) {
dev_err(&client->dev, "%s bytes=%d\n", __func__, sz);
for (i = 0; i < 50; i++) {
sz = <API key>(client,
<API key>);
if (sz > 0)
break;
}
if (i == 50) {
dev_dbg(&client->dev, "i2c failed... reset!!\n");
reset_mms_ts(info);
goto out;
}
}
/* BUG_ON(sz > MAX_FINGERS*FINGER_EVENT_SZ); */
if (sz == 0)
goto out;
if (sz > MAX_FINGERS*FINGER_EVENT_SZ) {
dev_err(&client->dev, "[TSP] abnormal data inputed.\n");
goto out;
}
msg[1].len = sz;
ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
if (ret != ARRAY_SIZE(msg)) {
dev_err(&client->dev,
"failed to read %d bytes of touch data (%d)\n",
sz, ret);
goto out;
}
#if defined(VERBOSE_DEBUG)
print_hex_dump(KERN_DEBUG, "mms_ts raw: ",
DUMP_PREFIX_OFFSET, 32, 1, buf, sz, false);
#endif
if (buf[0] == 0x0F) { /* ESD */
dev_dbg(&client->dev, "ESD DETECT.... reset!!\n");
reset_mms_ts(info);
goto out;
}
if (buf[0] == 0x0E) { /* NOISE MODE */
dev_dbg(&client->dev, "[TSP] noise mode enter!!\n");
info->noise_mode = 1 ;
mms_set_noise_mode(info);
goto out;
}
for (i = 0; i < sz; i += FINGER_EVENT_SZ) {
u8 *tmp = &buf[i];
int id = (tmp[0] & 0xf) - 1;
int x = tmp[2] | ((tmp[1] & 0xf) << 8);
int y = tmp[3] | (((tmp[1] >> 4) & 0xf) << 8);
int angle = (tmp[5] >= 127) ? (-(256 - tmp[5])) : tmp[5];
int palm = (tmp[0] & 0x10) >> 4;
if (info->invert_x) {
x = info->max_x - x;
if (x < 0)
x = 0;
}
if (info->invert_y) {
y = info->max_y - y;
if (y < 0)
y = 0;
}
if (id >= MAX_FINGERS) {
dev_notice(&client->dev, \
"finger id error [%d]\n", id);
reset_mms_ts(info);
goto out;
}
if ((tmp[0] & 0x80) == 0) {
#if defined(SEC_TSP_DEBUG)
dev_dbg(&client->dev,
"finger id[%d]: x=%d y=%d p=%d w=%d major=%d minor=%d angle=%d palm=%d\n",
id, x, y, tmp[5], tmp[4], tmp[6], tmp[7]
, angle, palm);
#else
if (info->finger_state[id] != 0) {
dev_notice(&client->dev,
"finger [%d] up, palm %d\n", id, palm);
}
#endif
input_mt_slot(info->input_dev, id);
<API key>(info->input_dev,
MT_TOOL_FINGER, false);
info->finger_state[id] = 0;
continue;
}
input_mt_slot(info->input_dev, id);
<API key>(info->input_dev,
MT_TOOL_FINGER, true);
input_report_abs(info->input_dev, ABS_MT_WIDTH_MAJOR, tmp[4]);
input_report_abs(info->input_dev, ABS_MT_POSITION_X, x);
input_report_abs(info->input_dev, ABS_MT_POSITION_Y, y);
input_report_abs(info->input_dev, ABS_MT_TOUCH_MAJOR, tmp[6]);
input_report_abs(info->input_dev, ABS_MT_TOUCH_MINOR, tmp[7]);
input_report_abs(info->input_dev, ABS_MT_ANGLE, angle);
input_report_abs(info->input_dev, ABS_MT_PALM, palm);
#if defined(SEC_TSP_DEBUG)
if (info->finger_state[id] == 0) {
info->finger_state[id] = 1;
dev_dbg(&client->dev,
"finger id[%d]: x=%d y=%d w=%d major=%d minor=%d angle=%d palm=%d\n",
id, x, y, tmp[4], tmp[6], tmp[7]
, angle, palm);
if (finger_event_sz == 10)
dev_dbg(&client->dev, \
"pressure = %d\n", tmp[8]);
}
#else
if (info->finger_state[id] == 0) {
info->finger_state[id] = 1;
dev_notice(&client->dev,
"finger [%d] down, palm %d\n", id, palm);
}
#endif
}
input_sync(info->input_dev);
touch_is_pressed = 0;
for (i = 0; i < MAX_FINGERS; i++) {
if (info->finger_state[i] == 1)
touch_is_pressed++;
}
#if TOUCH_BOOSTER
set_dvfs_lock(info, !!touch_is_pressed);
#endif
out:
return IRQ_HANDLED;
}
int get_tsp_status(void)
{
return touch_is_pressed;
}
EXPORT_SYMBOL(get_tsp_status);
#if ISC_DL_MODE
static int mms100_i2c_read(struct i2c_client *client,
u16 addr, u16 length, u8 *value)
{
struct i2c_adapter *adapter = client->adapter;
struct i2c_msg msg;
int ret = -1;
msg.addr = client->addr;
msg.flags = 0x00;
msg.len = 1;
msg.buf = (u8 *) &addr;
ret = i2c_transfer(adapter, &msg, 1);
if (ret >= 0) {
msg.addr = client->addr;
msg.flags = I2C_M_RD;
msg.len = length;
msg.buf = (u8 *) value;
ret = i2c_transfer(adapter, &msg, 1);
}
if (ret < 0)
pr_err("[TSP] : read error : [%d]", ret);
return ret;
}
static int mms100_reset(struct mms_ts_info *info)
{
info->pdata->power(false);
msleep(30);
info->pdata->power(true);
msleep(300);
return ISC_SUCCESS;
}
/*
static int <API key>(struct i2c_client *_client,
const int _error_code)
{
int ret;
unsigned char rd_buf = 0x00;
unsigned char count = 0;
if(_client == NULL)
pr_err("[TSP ISC] _client is null");
ret = mms100_i2c_read(_client, ISC_ADDR_VERSION, 1, &rd_buf);
if (ret<0) {
pr_info("[TSP ISC] %s,%d: i2c read fail[%d]\n",
__func__, __LINE__, ret);
return _error_code;
}
return ISC_SUCCESS;
}
*/
static int <API key>(struct i2c_client *_client)
{
int i, ret;
unsigned char rd_buf[8];
/* config version brust read (core, private, public) */
ret = mms100_i2c_read(_client, ISC_ADDR_VERSION, 4, rd_buf);
if (ret < 0) {
pr_info("[TSP ISC] %s,%d: i2c read fail[%d]\n",
__func__, __LINE__, ret);
return ISC_I2C_ERROR;
}
for (i = 0; i < SECTION_NUM; i++)
ts_info[i].version = rd_buf[i];
ts_info[SEC_CORE].compatible_version =
ts_info[SEC_BOOTLOADER].version;
ts_info[SEC_PRIVATE_CONFIG].compatible_version =
ts_info[SEC_PUBLIC_CONFIG].compatible_version =
ts_info[SEC_CORE].version;
ret = mms100_i2c_read(_client, <API key>, 8, rd_buf);
if (ret < 0) {
pr_info("[TSP ISC] %s,%d: i2c read fail[%d]\n",
__func__, __LINE__, ret);
return ISC_I2C_ERROR;
}
for (i = 0; i < SECTION_NUM; i++) {
ts_info[i].start_addr = rd_buf[i];
ts_info[i].end_addr = rd_buf[i + SECTION_NUM];
}
for (i = 0; i < SECTION_NUM; i++) {
pr_info("TS : Section(%d) version: 0x%02X\n",
i, ts_info[i].version);
pr_info("TS : Section(%d) Start Address: 0x%02X\n",
i, ts_info[i].start_addr);
pr_info("TS : Section(%d) End Address: 0x%02X\n",
i, ts_info[i].end_addr);
pr_info("TS : Section(%d) Compatibility: 0x%02X\n",
i, ts_info[i].compatible_version);
}
return ISC_SUCCESS;
}
static int <API key>(void)
{
int i;
char str_buf[STRING_BUF_LEN];
char name_buf[SECTION_NAME_LEN];
int version;
int page_num;
const unsigned char *buf;
int next_ptr;
for (i = 0; i < SECTION_NUM; i++) {
if (fw_mbin[i] == NULL) {
buf = NULL;
pr_info("[TSP ISC] fw_mbin[%d]->data is NULL", i);
} else {
buf = fw_mbin[i]->data;
}
if (buf == NULL) {
mbin_info[i].version = ts_info[i].version;
mbin_info[i].compatible_version =
ts_info[i].compatible_version;
mbin_info[i].start_addr = ts_info[i].start_addr;
mbin_info[i].end_addr = ts_info[i].end_addr;
} else {
next_ptr = 0;
do {
sscanf(buf + next_ptr, "%s", str_buf);
next_ptr += strlen(str_buf) + 1;
} while (!strstr(str_buf, "SECTION_NAME"));
sscanf(buf + next_ptr, "%s%s", str_buf, name_buf);
if (strncmp(section_name[i], name_buf,
SECTION_NAME_LEN))
return <API key>;
do {
sscanf(buf + next_ptr, "%s", str_buf);
next_ptr += strlen(str_buf) + 1;
} while (!strstr(str_buf, "SECTION_VERSION"));
sscanf(buf + next_ptr, "%s%d", str_buf, &version);
mbin_info[i].version = ISC_CHAR_2_BCD(version);
do {
sscanf(buf + next_ptr, "%s", str_buf);
next_ptr += strlen(str_buf) + 1;
} while (!strstr(str_buf, "START_PAGE_ADDR"));
sscanf(buf + next_ptr, "%s%d", str_buf, &page_num);
mbin_info[i].start_addr = page_num;
do {
sscanf(buf + next_ptr, "%s", str_buf);
next_ptr += strlen(str_buf) + 1;
} while (!strstr(str_buf, "END_PAGE_ADDR"));
sscanf(buf + next_ptr, "%s%d", str_buf, &page_num);
mbin_info[i].end_addr = page_num;
do {
sscanf(buf + next_ptr, "%s", str_buf);
next_ptr += strlen(str_buf) + 1;
} while (!strstr(str_buf, "COMPATIBLE_VERSION"));
sscanf(buf + next_ptr, "%s%d", str_buf, &version);
mbin_info[i].compatible_version =
ISC_CHAR_2_BCD(version);
do {
sscanf(buf + next_ptr, "%s", str_buf);
next_ptr += strlen(str_buf) + 1;
} while (!strstr(str_buf, "[Binary]"));
if (mbin_info[i].version == 0xFF)
return <API key>;
}
}
for (i = 0; i < SECTION_NUM; i++) {
pr_info("[TSP ISC] MBin : Section(%d) Version: 0x%02X\n",
i, mbin_info[i].version);
pr_info("[TSP ISC] MBin : Section(%d) Start Address: 0x%02X\n",
i, mbin_info[i].start_addr);
pr_info("[TSP ISC] MBin : Section(%d) End Address: 0x%02X\n",
i, mbin_info[i].end_addr);
pr_info("[TSP ISC] MBin : Section(%d) Compatibility: 0x%02X\n",
i, mbin_info[i].compatible_version);
}
return ISC_SUCCESS;
}
static eISCRet_t <API key>(struct i2c_client *_client)
{
int i, ret;
unsigned char <API key>[SECTION_NUM];
if (<API key>(_client) != ISC_SUCCESS)
return ISC_I2C_ERROR;
ret = <API key>();
/* Check update areas , 0 : bootloader 1: core 2: private 3: public */
for (i = 0; i < SECTION_NUM; i++) {
if ((mbin_info[i].version == 0) ||
(mbin_info[i].version != ts_info[i].version)) {
section_update_flag[i] = true;
pr_info("[TSP ISC] [%d] section will be updated!", i);
}
}
section_update_flag[0] = false;
pr_info("[TSP ISC] [%d] [%d] [%d]", section_update_flag[1],
section_update_flag[2], section_update_flag[3]);
if (section_update_flag[SEC_BOOTLOADER]) {
<API key>[SEC_CORE] =
mbin_info[SEC_BOOTLOADER].version;
} else {
<API key>[SEC_CORE] =
ts_info[SEC_BOOTLOADER].version;
}
if (section_update_flag[SEC_CORE]) {
<API key>[SEC_PUBLIC_CONFIG] =
<API key>[SEC_PRIVATE_CONFIG] =
mbin_info[SEC_CORE].version;
} else {
<API key>[SEC_PUBLIC_CONFIG] =
<API key>[SEC_PRIVATE_CONFIG] =
ts_info[SEC_CORE].version;
}
for (i = SEC_CORE; i < SEC_PUBLIC_CONFIG; i++) {
if (section_update_flag[i]) {
pr_info("[TSP ISC] section_update_flag(%d), 0x%02x, 0x%02x\n",
i, <API key>[i],
mbin_info[i].compatible_version);
if (<API key>[i] !=
mbin_info[i].compatible_version)
return <API key>;
} else {
pr_info("[TSP ISC] !section_update_flag(%d), 0x%02x, 0x%02x\n",
i, <API key>[i],
ts_info[i].compatible_version);
if (<API key>[i] !=
ts_info[i].compatible_version)
return <API key>;
}
}
return ISC_SUCCESS;
}
static int <API key>(struct i2c_client *_client)
{
int ret;
unsigned char wr_buf[2];
pr_info("[TSP ISC] %s\n", __func__);
wr_buf[0] = ISC_CMD_ENTER_ISC;
wr_buf[1] = <API key>;
ret = i2c_master_send(_client, wr_buf, 2);
if (ret < 0) {
pr_info("[TSP ISC] %s,%d: i2c write fail[%d]\n",
__func__, __LINE__, ret);
return ISC_I2C_ERROR;
}
msleep(50);
return ISC_SUCCESS;
}
static int <API key>(struct i2c_client *_client)
{
int ret;
unsigned char wr_buf[10] = {0,};
unsigned char rd_buf;
wr_buf[0] = ISC_CMD_UPDATE_MODE;
wr_buf[1] = <API key>;
ret = i2c_master_send(_client, wr_buf, 10);
if (ret < 0) {
pr_info("[TSP ISC] %s,%d: i2c write fail[%d]\n",
__func__, __LINE__, ret);
return ISC_I2C_ERROR;
}
ret = mms100_i2c_read(_client, <API key>, 1, &rd_buf);
if (ret < 0) {
pr_info("[TSP ISC] %s,%d: i2c read fail[%d]\n",
__func__, __LINE__, ret);
return ISC_I2C_ERROR;
}
if (rd_buf != <API key>)
return <API key>;
pr_info("[TSP ISC]End <API key>()\n");
return ISC_SUCCESS;
}
static int <API key>(struct i2c_client *_client,
unsigned char _page_addr)
{
int ret;
unsigned char rd_buf;
memset(&g_wr_buf[3], 0xFF, PAGE_DATA);
g_wr_buf[0] = ISC_CMD_UPDATE_MODE; /* command */
g_wr_buf[1] = <API key>; /* sub_command */
g_wr_buf[2] = _page_addr;
g_wr_buf[PAGE_HEADER + PAGE_DATA] = crc0_buf[_page_addr];
g_wr_buf[PAGE_HEADER + PAGE_DATA + 1] = crc1_buf[_page_addr];
ret = i2c_master_send(_client, g_wr_buf, PACKET_SIZE);
if (ret < 0) {
pr_info("[TSP ISC] %s,%d: i2c write fail[%d]\n",
__func__, __LINE__, ret);
return ISC_I2C_ERROR;
}
ret = mms100_i2c_read(_client, <API key>, 1, &rd_buf);
if (ret < 0) {
pr_info("[TSP ISC] %s,%d: i2c read fail[%d]\n",
__func__, __LINE__, ret);
return ISC_I2C_ERROR;
}
if (rd_buf != <API key>)
return <API key>;
pr_info("[TSP ISC]End <API key>()\n");
return ISC_SUCCESS;
}
static int <API key>(struct i2c_client *_client)
{
int ret_msg;
int i, j;
bool is_matched_address;
for (i = SEC_CORE; i <= SEC_PUBLIC_CONFIG; i++) {
if (section_update_flag[i]) {
if (ts_info[i].end_addr <= 30 &&
ts_info[i].end_addr > 0) {
ret_msg = <API key>(_client,
ts_info[i].end_addr);
if (ret_msg != ISC_SUCCESS)
return ret_msg;
}
}
}
for (i = SEC_CORE; i <= SEC_PUBLIC_CONFIG; i++) {
if (section_update_flag[i]) {
is_matched_address = false;
for (j = SEC_CORE; j <= SEC_PUBLIC_CONFIG; j++) {
if (mbin_info[i].end_addr ==
ts_info[i].end_addr) {
is_matched_address = true;
break;
}
}
if (!is_matched_address) {
if (mbin_info[i].end_addr <= 30 &&
mbin_info[i].end_addr > 0) {
ret_msg = <API key>(_client,
mbin_info[i].end_addr);
if (ret_msg != ISC_SUCCESS)
return ret_msg;
}
}
}
}
return ISC_SUCCESS;
}
static int <API key>(struct i2c_client *_client)
{
int i, ret, next_ptr;
unsigned char rd_buf;
const unsigned char *ptr_fw;
char str_buf[STRING_BUF_LEN];
int page_addr;
for (i = 0; i < SECTION_NUM; i++) {
if (section_update_flag[i]) {
pr_info("[TSP ISC] section data i2c flash : [%d]", i);
next_ptr = 0;
ptr_fw = fw_mbin[i]->data;
do {
sscanf(ptr_fw + next_ptr, "%s", str_buf);
next_ptr += strlen(str_buf) + 1;
} while (!strstr(str_buf, "[Binary]"));
ptr_fw = ptr_fw + next_ptr + 2;
for (page_addr = mbin_info[i].start_addr;
page_addr <= mbin_info[i].end_addr;
page_addr++) {
if (page_addr - mbin_info[i].start_addr > 0)
ptr_fw += PACKET_SIZE;
if ((ptr_fw[0] != ISC_CMD_UPDATE_MODE) ||
(ptr_fw[1] != <API key>) ||
(ptr_fw[2] != page_addr))
return <API key>;
ret = i2c_master_send(_client,
ptr_fw, PACKET_SIZE);
if (ret < 0) {
pr_info("[TSP ISC] %s,%d: i2c write fail[%d]\n",
__func__, __LINE__, ret);
return ISC_I2C_ERROR;
}
ret = mms100_i2c_read(_client,
<API key>, 1, &rd_buf);
if (ret < 0) {
pr_info("[TSP ISC] %s,%d: i2c read fail[%d]\n",
__func__, __LINE__, ret);
return ISC_I2C_ERROR;
}
if (rd_buf != <API key>)
return ISC_CRC_ERROR;
section_update_flag[i] = false;
}
}
}
pr_info("[TSP ISC]End <API key>()\n");
return ISC_SUCCESS;
}
static eISCRet_t mms100_open_mbinary(struct i2c_client *_client)
{
int i;
char file_name[64];
int ret = 0;
ret += request_firmware(&(fw_mbin[1]),\
"tsp_melfas/CORE.fw", &_client->dev);
ret += request_firmware(&(fw_mbin[2]),\
"tsp_melfas/PRIV.fw", &_client->dev);
ret += request_firmware(&(fw_mbin[3]),\
"tsp_melfas/PUBL.fw", &_client->dev);
if (!ret)
return ISC_SUCCESS;
else {
pr_info("[TSP ISC] request_firmware fail");
return ret;
}
}
static eISCRet_t <API key>(void)
{
int i;
for (i = 0; i < SECTION_NUM; i++) {
if (fw_mbin[i] != NULL)
release_firmware(fw_mbin[i]);
}
return ISC_SUCCESS;
}
eISCRet_t <API key>(struct mms_ts_info *info)
{
struct i2c_client *_client = info->client;
eISCRet_t ret_msg = ISC_NONE;
pr_info("[TSP ISC] %s\n", __func__);
mms100_reset(info);
/* ret_msg = <API key>(_client, <API key>);
if (ret_msg != ISC_SUCCESS)
goto ISC_ERROR_HANDLE;
*/
ret_msg = mms100_open_mbinary(_client);
if (ret_msg != ISC_SUCCESS)
goto ISC_ERROR_HANDLE;
/*Config version Check*/
ret_msg = <API key>(_client);
if (ret_msg != ISC_SUCCESS)
goto ISC_ERROR_HANDLE;
ret_msg = <API key>(_client);
if (ret_msg != ISC_SUCCESS)
goto ISC_ERROR_HANDLE;
ret_msg = <API key>(_client);
if (ret_msg != ISC_SUCCESS)
goto ISC_ERROR_HANDLE;
ret_msg = <API key>(_client);
if (ret_msg != ISC_SUCCESS)
goto ISC_ERROR_HANDLE;
pr_info("[TSP ISC]<API key> start");
ret_msg = <API key>(_client);
if (ret_msg != ISC_SUCCESS)
goto ISC_ERROR_HANDLE;
pr_info("[TSP ISC]<API key> end");
/* mms100_reset(info); */
pr_info("[TSP ISC]<API key>!!!\n");
ret_msg = ISC_SUCCESS;
ISC_ERROR_HANDLE:
if (ret_msg != ISC_SUCCESS)
pr_info("[TSP ISC]ISC_ERROR_CODE: %d\n", ret_msg);
mms100_reset(info);
<API key>();
return ret_msg;
}
#endif /* ISC_DL_MODE start */
static void hw_reboot(struct mms_ts_info *info, bool bootloader)
{
info->pdata->power(false);
<API key>(info->pdata->gpio_sda, bootloader ? 0 : 1);
<API key>(info->pdata->gpio_scl, bootloader ? 0 : 1);
<API key>(info->pdata->gpio_int, 0);
msleep(30);
info->pdata->power(true);
msleep(30);
if (bootloader) {
gpio_set_value(info->pdata->gpio_scl, 0);
gpio_set_value(info->pdata->gpio_sda, 1);
} else {
gpio_set_value(info->pdata->gpio_int, 1);
<API key>(info->pdata->gpio_int);
<API key>(info->pdata->gpio_scl);
<API key>(info->pdata->gpio_sda);
}
msleep(40);
}
static inline void <API key>(struct mms_ts_info *info)
{
hw_reboot(info, true);
}
static inline void hw_reboot_normal(struct mms_ts_info *info)
{
hw_reboot(info, false);
}
static void isp_toggle_clk(struct mms_ts_info *info, int start_lvl, int end_lvl,
int hold_us)
{
gpio_set_value(info->pdata->gpio_scl, start_lvl);
udelay(hold_us);
gpio_set_value(info->pdata->gpio_scl, end_lvl);
udelay(hold_us);
}
/* 1 <= cnt <= 32 bits to write */
static void isp_send_bits(struct mms_ts_info *info, u32 data, int cnt)
{
<API key>(info->pdata->gpio_int, 0);
<API key>(info->pdata->gpio_scl, 0);
<API key>(info->pdata->gpio_sda, 0);
/* clock out the bits, msb first */
while (cnt
gpio_set_value(info->pdata->gpio_sda, (data >> cnt) & 1);
udelay(3);
isp_toggle_clk(info, 1, 0, 3);
}
}
/* 1 <= cnt <= 32 bits to read */
static u32 isp_recv_bits(struct mms_ts_info *info, int cnt)
{
u32 data = 0;
<API key>(info->pdata->gpio_int, 0);
<API key>(info->pdata->gpio_scl, 0);
gpio_set_value(info->pdata->gpio_sda, 0);
<API key>(info->pdata->gpio_sda);
/* clock in the bits, msb first */
while (cnt
isp_toggle_clk(info, 0, 1, 1);
data = (data << 1) | (!!gpio_get_value(info->pdata->gpio_sda));
}
<API key>(info->pdata->gpio_sda, 0);
return data;
}
static void isp_enter_mode(struct mms_ts_info *info, u32 mode)
{
int cnt;
unsigned long flags;
local_irq_save(flags);
<API key>(info->pdata->gpio_int, 0);
<API key>(info->pdata->gpio_scl, 0);
<API key>(info->pdata->gpio_sda, 1);
mode &= 0xffff;
for (cnt = 15; cnt >= 0; cnt
gpio_set_value(info->pdata->gpio_int, (mode >> cnt) & 1);
udelay(3);
isp_toggle_clk(info, 1, 0, 3);
}
gpio_set_value(info->pdata->gpio_int, 0);
local_irq_restore(flags);
}
static void isp_exit_mode(struct mms_ts_info *info)
{
int i;
unsigned long flags;
local_irq_save(flags);
<API key>(info->pdata->gpio_int, 0);
udelay(3);
for (i = 0; i < 10; i++)
isp_toggle_clk(info, 1, 0, 3);
local_irq_restore(flags);
}
static void flash_set_address(struct mms_ts_info *info, u16 addr)
{
/* Only 13 bits of addr are valid.
* The addr is in bits 13:1 of cmd */
isp_send_bits(info, (u32) (addr & 0x1fff) << 1, 18);
}
static void flash_erase(struct mms_ts_info *info)
{
isp_enter_mode(info, <API key>);
<API key>(info->pdata->gpio_int, 0);
<API key>(info->pdata->gpio_scl, 0);
<API key>(info->pdata->gpio_sda, 1);
/* 4 clock cycles with different timings for the erase to
* get processed, clk is already 0 from above */
udelay(7);
isp_toggle_clk(info, 1, 0, 3);
udelay(7);
isp_toggle_clk(info, 1, 0, 3);
usleep_range(25000, 35000);
isp_toggle_clk(info, 1, 0, 3);
usleep_range(150, 200);
isp_toggle_clk(info, 1, 0, 3);
gpio_set_value(info->pdata->gpio_sda, 0);
isp_exit_mode(info);
}
static u32 flash_readl(struct mms_ts_info *info, u16 addr)
{
int i;
u32 val;
unsigned long flags;
local_irq_save(flags);
isp_enter_mode(info, ISP_MODE_FLASH_READ);
flash_set_address(info, addr);
<API key>(info->pdata->gpio_scl, 0);
<API key>(info->pdata->gpio_sda, 0);
udelay(40);
/* data load cycle */
for (i = 0; i < 6; i++)
isp_toggle_clk(info, 1, 0, 10);
val = isp_recv_bits(info, 32);
isp_exit_mode(info);
local_irq_restore(flags);
return val;
}
static void flash_writel(struct mms_ts_info *info, u16 addr, u32 val)
{
unsigned long flags;
local_irq_save(flags);
isp_enter_mode(info, <API key>);
flash_set_address(info, addr);
isp_send_bits(info, val, 32);
<API key>(info->pdata->gpio_sda, 1);
/* 6 clock cycles with different timings for the data to get written
* into flash */
isp_toggle_clk(info, 0, 1, 3);
isp_toggle_clk(info, 0, 1, 3);
isp_toggle_clk(info, 0, 1, 6);
isp_toggle_clk(info, 0, 1, 12);
isp_toggle_clk(info, 0, 1, 3);
isp_toggle_clk(info, 0, 1, 3);
isp_toggle_clk(info, 1, 0, 1);
<API key>(info->pdata->gpio_sda, 0);
isp_exit_mode(info);
local_irq_restore(flags);
usleep_range(300, 400);
}
static bool flash_is_erased(struct mms_ts_info *info)
{
struct i2c_client *client = info->client;
u32 val;
u16 addr;
for (addr = 0; addr < (ISP_MAX_FW_SIZE / 4); addr++) {
udelay(40);
val = flash_readl(info, addr);
if (val != 0xffffffff) {
dev_dbg(&client->dev,
"addr 0x%x not erased: 0x%08x != 0xffffffff\n",
addr, val);
return false;
}
}
return true;
}
static int fw_write_image(struct mms_ts_info *info, const u8 * data, size_t len)
{
struct i2c_client *client = info->client;
u16 addr = 0;
for (addr = 0; addr < (len / 4); addr++, data += 4) {
u32 val = get_unaligned_le32(data);
u32 verify_val;
int retries = 3;
while (retries
flash_writel(info, addr, val);
verify_val = flash_readl(info, addr);
if (val == verify_val)
break;
dev_err(&client->dev,
"mismatch @ addr 0x%x: 0x%x != 0x%x\n",
addr, verify_val, val);
continue;
}
if (retries < 0)
return -ENXIO;
}
return 0;
}
static int fw_download(struct mms_ts_info *info, const u8 * data, size_t len)
{
struct i2c_client *client = info->client;
u32 val;
int ret = 0;
if (len % 4) {
dev_err(&client->dev,
"fw image size (%d) must be a multiple of 4 bytes\n",
len);
return -EINVAL;
} else if (len > ISP_MAX_FW_SIZE) {
dev_err(&client->dev,
"fw image is too big, %d > %d\n", len, ISP_MAX_FW_SIZE);
return -EINVAL;
}
dev_info(&client->dev, "fw download start\n");
info->pdata->power(false);
<API key>(info->pdata->gpio_sda, 0);
<API key>(info->pdata->gpio_scl, 0);
<API key>(info->pdata->gpio_int, 0);
<API key>(info);
val = flash_readl(info, ISP_IC_INFO_ADDR);
dev_info(&client->dev, "IC info: 0x%02x (%x)\n", val & 0xff, val);
dev_info(&client->dev, "fw erase...\n");
flash_erase(info);
if (!flash_is_erased(info)) {
ret = -ENXIO;
goto err;
}
dev_info(&client->dev, "fw write...\n");
/* XXX: what does this do?! */
flash_writel(info, ISP_IC_INFO_ADDR, 0xffffff00 | (val & 0xff));
usleep_range(1000, 1500);
ret = fw_write_image(info, data, len);
if (ret)
goto err;
usleep_range(1000, 1500);
hw_reboot_normal(info);
usleep_range(1000, 1500);
dev_info(&client->dev, "fw download done...\n");
return 0;
err:
dev_err(&client->dev, "fw download failed...\n");
hw_reboot_normal(info);
return ret;
}
#if defined(<API key>)
static u16 gen_crc(u8 data, u16 pre_crc)
{
u16 crc;
u16 cur;
u16 temp;
u16 bit_1;
u16 bit_2;
int i;
crc = pre_crc;
for (i = 7; i >= 0; i
cur = ((data >> i) & 0x01) ^ (crc & 0x0001);
bit_1 = cur ^ (crc >> 11 & 0x01);
bit_2 = cur ^ (crc >> 4 & 0x01);
temp = (cur << 4) | (crc >> 12 & 0x0F);
temp = (temp << 7) | (bit_1 << 6) | (crc >> 5 & 0x3F);
temp = (temp << 4) | (bit_2 << 3) | (crc >> 1 & 0x0007);
crc = temp;
}
return crc;
}
static int isc_fw_download(struct mms_ts_info *info, const u8 * data,
size_t len)
{
u8 *buff;
u16 crc_buf;
int src_idx;
int dest_idx;
int ret;
int i, j;
buff = kzalloc(ISC_PKT_SIZE, GFP_KERNEL);
if (!buff) {
dev_err(&info->client->dev, "%s: failed to allocate memory\n",
__func__);
ret = -1;
goto err_mem_alloc;
}
/* enterring ISC mode */
*buff = ISC_ENTER_ISC_DATA;
ret = <API key>(info->client,
ISC_ENTER_ISC_CMD, *buff);
if (ret < 0) {
dev_err(&info->client->dev,
"fail to enter ISC mode(err=%d)\n", ret);
goto fail_to_isc_enter;
}
usleep_range(10000, 20000);
dev_info(&info->client->dev, "Enter ISC mode\n");
/*enter ISC update mode */
*buff = <API key>;
ret = <API key>(info->client,
ISC_CMD,
<API key>, buff);
if (ret < 0) {
dev_err(&info->client->dev,
"fail to enter ISC update mode(err=%d)\n", ret);
goto fail_to_isc_update;
}
dev_info(&info->client->dev, "Enter ISC update mode\n");
/* firmware write */
*buff = ISC_CMD;
*(buff + 1) = <API key>;
for (i = 0; i < ISC_PKT_NUM; i++) {
*(buff + 2) = i;
crc_buf = gen_crc(*(buff + 2), ISC_DEFAULT_CRC);
for (j = 0; j < ISC_PKT_DATA_SIZE; j++) {
dest_idx = ISC_PKT_HEADER_SIZE + j;
src_idx = i * ISC_PKT_DATA_SIZE +
((int)(j / WORD_SIZE)) * WORD_SIZE -
(j % WORD_SIZE) + 3;
*(buff + dest_idx) = *(data + src_idx);
crc_buf = gen_crc(*(buff + dest_idx), crc_buf);
}
*(buff + ISC_PKT_DATA_SIZE + ISC_PKT_HEADER_SIZE + 1) =
crc_buf & 0xFF;
*(buff + ISC_PKT_DATA_SIZE + ISC_PKT_HEADER_SIZE) =
crc_buf >> 8 & 0xFF;
ret = i2c_master_send(info->client, buff, ISC_PKT_SIZE);
if (ret < 0) {
dev_err(&info->client->dev,
"fail to firmware writing on packet %d.(%d)\n",
i, ret);
goto fail_to_fw_write;
}
usleep_range(1, 5);
/* confirm CRC */
ret = <API key>(info->client,
<API key>);
if (ret == ISC_CONFIRM_CRC) {
dev_info(&info->client->dev,
"updating %dth firmware data packet.\n", i);
} else {
dev_err(&info->client->dev,
"fail to firmware update on %dth (%X).\n",
i, ret);
ret = -1;
goto fail_to_confirm_crc;
}
}
ret = 0;
fail_to_confirm_crc:
fail_to_fw_write:
/* exit ISC mode */
*buff = <API key>;
*(buff + 1) = <API key>;
<API key>(info->client, ISC_CMD, 2, buff);
usleep_range(10000, 20000);
fail_to_isc_update:
hw_reboot_normal(info);
fail_to_isc_enter:
kfree(buff);
err_mem_alloc:
return ret;
}
#endif /* <API key> */
static int get_fw_version(struct mms_ts_info *info)
{
int ret;
int retries = 3;
/* this seems to fail sometimes after a reset.. retry a few times */
do {
ret = <API key>(info->client, MMS_FW_VERSION);
} while (ret < 0 && retries
return ret;
}
static int get_hw_version(struct mms_ts_info *info)
{
int ret;
int retries = 3;
/* this seems to fail sometimes after a reset.. retry a few times */
do {
ret = <API key>(info->client, MMS_HW_REVISION);
} while (ret < 0 && retries
return ret;
}
static int mms_ts_enable(struct mms_ts_info *info, int wakeupcmd)
{
mutex_lock(&info->lock);
if (info->enabled)
goto out;
/* wake up the touch controller. */
if (wakeupcmd == 1) {
<API key>(info->client, 0, 0);
usleep_range(3000, 5000);
}
info->enabled = true;
enable_irq(info->irq);
out:
mutex_unlock(&info->lock);
return 0;
}
static int mms_ts_disable(struct mms_ts_info *info, int sleepcmd)
{
mutex_lock(&info->lock);
if (!info->enabled)
goto out;
disable_irq_nosync(info->irq);
if (sleepcmd == 1) {
<API key>(info->client, MMS_MODE_CONTROL, 0);
usleep_range(10000, 12000);
}
info->enabled = false;
touch_is_pressed = 0;
out:
mutex_unlock(&info->lock);
return 0;
}
static int <API key>(struct mms_ts_info *info)
{
struct i2c_client *client = info->client;
int ret;
ret = <API key>(client->irq, NULL, mms_ts_interrupt,
IRQF_TRIGGER_LOW | IRQF_ONESHOT,
MELFAS_TS_NAME, info);
if (ret < 0) {
ret = 1;
dev_err(&client->dev, "Failed to register interrupt\n");
goto err_req_irq;
}
info->irq = client->irq;
barrier();
dev_info(&client->dev,
"Melfas MMS-series touch controller initialized\n");
return 0;
err_req_irq:
return ret;
}
static int mms_ts_fw_info(struct mms_ts_info *info)
{
struct i2c_client *client = info->client;
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
int ret = 0;
int ver, hw_rev;
ver = get_fw_version(info);
info->fw_ic_ver = ver;
dev_info(&client->dev,
"[TSP]fw version 0x%02x !!!!\n", ver);
hw_rev = get_hw_version(info);
dev_info(&client->dev,
"[TSP] hw rev = %x\n", hw_rev);
if (ver < 0 || hw_rev < 0) {
ret = 1;
dev_err(&client->dev,
"i2c fail...tsp driver unload.\n");
return ret;
}
if (!info->pdata || !info->pdata->mux_fw_flash) {
ret = 1;
dev_err(&client->dev,
"fw cannot be updated, missing platform data\n");
return ret;
}
ret = <API key>(info);
return ret;
}
static int mms_ts_fw_load(struct mms_ts_info *info)
{
struct i2c_client *client = info->client;
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
int ret = 0;
int ver, hw_rev;
int retries = 3;
ver = get_fw_version(info);
info->fw_ic_ver = ver;
dev_info(&client->dev,
"[TSP]fw version 0x%02x !!!!\n", ver);
hw_rev = get_hw_version(info);
dev_info(&client->dev,
"[TSP]hw rev = 0x%02x\n", hw_rev);
pr_err("[TSP] ISC Ver [0x%02x] [0x%02x] [0x%02x]",
<API key>(info->client, 0xF3),
<API key>(info->client, 0xF4),
<API key>(info->client, 0xF5));
if (!info->pdata || !info->pdata->mux_fw_flash) {
ret = 1;
dev_err(&client->dev,
"fw cannot be updated, missing platform data\n");
goto out;
}
/* 4.8" OCTA LCD FW */
if (ver >= FW_VERSION_4_8 && ver != 0xFF\
&& ver != 0x00 && ver != 0x45) {
dev_info(&client->dev,
"4.8 fw version update does not need\n");
goto done;
}
while (retries
ret = <API key>(info);
ver = get_fw_version(info);
info->fw_ic_ver = ver;
if (ret == 0) {
pr_err("[TSP] <API key> success");
goto done;
} else {
pr_err("[TSP] <API key> fail [%d]",
ret);
ret = 1;
}
dev_err(&client->dev, "retrying flashing\n");
}
out:
return ret;
done:
#if ISC_DL_MODE /* ISC_DL_MODE start */
pr_err("[TSP] ISC Ver [0x%02x] [0x%02x] [0x%02x]",
<API key>(info->client, 0xF3),
<API key>(info->client, 0xF4),
<API key>(info->client, 0xF5));
#endif
ret = <API key>(info);
return ret;
}
#ifdef <API key>
static void set_cmd_result(struct mms_ts_info *info, char *buff, int len)
{
strncat(info->cmd_result, buff, len);
}
static void get_raw_data_all(struct mms_ts_info *info, u8 cmd)
{
u8 w_buf[6];
u8 read_buffer[2];
int gpio;
int ret;
int i, j;
u32 max_value = 0, min_value = 0;
u32 raw_data;
char buff[TSP_CMD_STR_LEN] = {0};
gpio = info->pdata->gpio_int;
/* gpio = msm_irq_to_gpio(info->irq); */
disable_irq(info->irq);
w_buf[0] = MMS_VSC_CMD; /* vendor specific command id */
w_buf[1] = MMS_VSC_MODE; /* mode of vendor */
w_buf[2] = 0; /* tx line */
w_buf[3] = 0; /* rx line */
w_buf[4] = 0; /* reserved */
w_buf[5] = 0; /* sub command */
if (cmd == MMS_VSC_CMD_EXIT) {
w_buf[5] = MMS_VSC_CMD_EXIT; /* exit test mode */
ret = <API key>(info->client,
w_buf[0], 5, &w_buf[1]);
if (ret < 0)
goto err_i2c;
enable_irq(info->irq);
msleep(200);
return;
}
/* <API key> or MMS_VSC_CMD_CM_ABS
* this two mode need to enter the test mode
* exit command must be followed by testing.
*/
if (cmd == <API key> || cmd == MMS_VSC_CMD_CM_ABS) {
/* enter the debug mode */
w_buf[2] = 0x0;
w_buf[3] = 0x0;
w_buf[5] = MMS_VSC_CMD_ENTER;
ret = <API key>(info->client,
w_buf[0], 5, &w_buf[1]);
if (ret < 0)
goto err_i2c;
/* wating for the interrupt */
while (gpio_get_value(gpio))
udelay(100);
}
for (i = 0; i < RX_NUM; i++) {
for (j = 0; j < TX_NUM; j++) {
w_buf[2] = j;
w_buf[3] = i;
w_buf[5] = cmd;
ret = <API key>(info->client,
w_buf[0], 5, &w_buf[1]);
if (ret < 0)
goto err_i2c;
usleep_range(1, 5);
ret = <API key>(info->client, 0xBF,
2, read_buffer);
if (ret < 0)
goto err_i2c;
raw_data = ((u16) read_buffer[1] << 8) | read_buffer[0];
if (i == 0 && j == 0) {
max_value = min_value = raw_data;
} else {
max_value = max(max_value, raw_data);
min_value = min(min_value, raw_data);
}
if (cmd == <API key>) {
info->intensity[i * TX_NUM + j] = raw_data;
dev_dbg(&info->client->dev, "[TSP] intensity[%d][%d] = %d\n",
j, i, info->intensity[i * TX_NUM + j]);
} else if (cmd == <API key>) {
info->inspection[i * TX_NUM + j] = raw_data;
dev_dbg(&info->client->dev, "[TSP] delta[%d][%d] = %d\n",
j, i, info->inspection[i * TX_NUM + j]);
} else if (cmd == MMS_VSC_CMD_CM_ABS) {
info->raw[i * TX_NUM + j] = raw_data;
dev_dbg(&info->client->dev, "[TSP] raw[%d][%d] = %d\n",
j, i, info->raw[i * TX_NUM + j]);
} else if (cmd == MMS_VSC_CMD_REFER) {
info->reference[i * TX_NUM + j] =
raw_data >> 3;
dev_dbg(&info->client->dev, "[TSP] reference[%d][%d] = %d\n",
j, i, info->reference[i * TX_NUM + j]);
}
}
}
snprintf(buff, sizeof(buff), "%d,%d", min_value, max_value);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
enable_irq(info->irq);
err_i2c:
dev_err(&info->client->dev, "%s: fail to i2c (cmd=%d)\n",
__func__, cmd);
}
static u32 get_raw_data_one(struct mms_ts_info *info, u16 rx_idx, u16 tx_idx,
u8 cmd)
{
u8 w_buf[6];
u8 read_buffer[2];
int ret;
u32 raw_data;
w_buf[0] = MMS_VSC_CMD; /* vendor specific command id */
w_buf[1] = MMS_VSC_MODE; /* mode of vendor */
w_buf[2] = 0; /* tx line */
w_buf[3] = 0; /* rx line */
w_buf[4] = 0; /* reserved */
w_buf[5] = 0; /* sub command */
if (cmd != <API key> && cmd != MMS_VSC_CMD_RAW &&
cmd != MMS_VSC_CMD_REFER) {
dev_err(&info->client->dev, "%s: not profer command(cmd=%d)\n",
__func__, cmd);
return FAIL;
}
w_buf[2] = tx_idx;
w_buf[3] = rx_idx;
w_buf[5] = cmd; /* sub command */
ret = <API key>(info->client, w_buf[0], 5,
&w_buf[1]);
if (ret < 0)
goto err_i2c;
ret = <API key>(info->client, 0xBF, 2, read_buffer);
if (ret < 0)
goto err_i2c;
raw_data = ((u16) read_buffer[1] << 8) | read_buffer[0];
if (cmd == MMS_VSC_CMD_REFER)
raw_data = raw_data >> 4;
return raw_data;
err_i2c:
dev_err(&info->client->dev, "%s: fail to i2c (cmd=%d)\n",
__func__, cmd);
return FAIL;
}
static ssize_t show_close_tsp_test(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct mms_ts_info *info = dev_get_drvdata(dev);
get_raw_data_all(info, MMS_VSC_CMD_EXIT);
info->ft_flag = 0;
return snprintf(buf, TSP_BUF_SIZE, "%u\n", 0);
}
static void set_default_result(struct mms_ts_info *info)
{
char delim = ':';
memset(info->cmd_result, 0x00, ARRAY_SIZE(info->cmd_result));
memcpy(info->cmd_result, info->cmd, strlen(info->cmd));
strncat(info->cmd_result, &delim, 1);
}
static int check_rx_tx_num(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[TSP_CMD_STR_LEN] = {0};
int node;
if (info->cmd_param[0] < 0 ||
info->cmd_param[0] >= TX_NUM ||
info->cmd_param[1] < 0 ||
info->cmd_param[1] >= RX_NUM) {
snprintf(buff, sizeof(buff) , "%s", "NG");
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 3;
dev_info(&info->client->dev, "%s: parameter error: %u,%u\n",
__func__, info->cmd_param[0],
info->cmd_param[1]);
node = -1;
return node;
}
node = info->cmd_param[1] * TX_NUM + info->cmd_param[0];
dev_info(&info->client->dev, "%s: node = %d\n", __func__,
node);
return node;
}
static void not_support_cmd(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
set_default_result(info);
sprintf(buff, "%s", "NA");
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 4;
dev_info(&info->client->dev, "%s: \"%s(%d)\"\n", __func__,
buff, strnlen(buff, sizeof(buff)));
return;
}
static void fw_update(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
struct i2c_client *client = info->client;
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
int ret = 0;
int ver = 0, fw_bin_ver = 0;
int retries = 5;
const u8 *buff = 0;
mm_segment_t old_fs = {0};
struct file *fp = NULL;
long fsize = 0, nread = 0;
char fw_path[MAX_FW_PATH+1];
char result[16] = {0};
set_default_result(info);
dev_info(&client->dev,
"fw_ic_ver = 0x%02x, fw_bin_ver = 0x%02x\n",
info->fw_ic_ver, fw_bin_ver);
switch (info->cmd_param[0]) {
case BUILT_IN:
dev_info(&client->dev, "built in 4.8 fw is loaded!!\n");
while (retries
ret = <API key>(info);
ver = get_fw_version(info);
info->fw_ic_ver = ver;
if (ret == 0) {
pr_err("[TSP] <API key> success");
info->cmd_state = 2;
return;
} else {
pr_err("[TSP] <API key> fail[%d]",
ret);
info->cmd_state = 3;
}
}
return;
break;
case UMS:
old_fs = get_fs();
set_fs(get_ds());
snprintf(fw_path, MAX_FW_PATH, "/sdcard/%s", TSP_FW_FILENAME);
fp = filp_open(fw_path, O_RDONLY, 0);
if (IS_ERR(fp)) {
dev_err(&client->dev,
"file %s open error:%d\n", fw_path, (s32)fp);
info->cmd_state = 3;
goto err_open;
}
fsize = fp->f_path.dentry->d_inode->i_size;
buff = kzalloc((size_t)fsize, GFP_KERNEL);
if (!buff) {
dev_err(&client->dev, "fail to alloc buffer for fw\n");
info->cmd_state = 3;
goto err_alloc;
}
nread = vfs_read(fp, (char __user *)buff, fsize, &fp->f_pos);
if (nread != fsize) {
/*dev_err("fail to read file %s (nread = %d)\n",
fw_path, nread);*/
info->cmd_state = 3;
goto err_fw_size;
}
filp_close(fp, current->files);
set_fs(old_fs);
dev_info(&client->dev, "ums fw is loaded!!\n");
break;
default:
dev_err(&client->dev, "invalid fw file type!!\n");
goto not_support;
}
disable_irq(info->irq);
while (retries
i2c_lock_adapter(adapter);
info->pdata->mux_fw_flash(true);
ret = fw_download(info, (const u8 *)buff,
(const size_t)fsize);
info->pdata->mux_fw_flash(false);
i2c_unlock_adapter(adapter);
if (ret < 0) {
dev_err(&client->dev, "retrying flashing\n");
continue;
}
ver = get_fw_version(info);
info->fw_ic_ver = ver;
if (info->cmd_param[0] == 1 || info->cmd_param[0] == 2) {
dev_info(&client->dev,
"fw update done. ver = 0x%02x\n", ver);
info->cmd_state = 2;
snprintf(result, sizeof(result) , "%s", "OK");
set_cmd_result(info, result,
strnlen(result, sizeof(result)));
enable_irq(info->irq);
kfree(buff);
return;
} else if (ver == fw_bin_ver) {
dev_info(&client->dev,
"fw update done. ver = 0x%02x\n", ver);
info->cmd_state = 2;
snprintf(result, sizeof(result) , "%s", "OK");
set_cmd_result(info, result,
strnlen(result, sizeof(result)));
enable_irq(info->irq);
return;
} else {
dev_err(&client->dev,
"ERROR : fw version is still wrong (0x%x != 0x%x)\n",
ver, fw_bin_ver);
}
dev_err(&client->dev, "retrying flashing\n");
}
if (fp != NULL) {
err_fw_size:
kfree(buff);
err_alloc:
filp_close(fp, NULL);
err_open:
set_fs(old_fs);
}
not_support:
do_not_need_update:
snprintf(result, sizeof(result) , "%s", "NG");
set_cmd_result(info, result, strnlen(result, sizeof(result)));
return;
}
static void get_fw_ver_bin(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
int hw_rev;
set_default_result(info);
snprintf(buff, sizeof(buff), "%#02x", FW_VERSION_4_8);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__,
buff, strnlen(buff, sizeof(buff)));
}
static void get_fw_ver_ic(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
int ver;
set_default_result(info);
ver = info->fw_ic_ver;
snprintf(buff, sizeof(buff), "%#02x", ver);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__,
buff, strnlen(buff, sizeof(buff)));
}
static void get_config_ver(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[20] = {0};
set_default_result(info);
snprintf(buff, sizeof(buff), "%s", info->config_fw_version);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__,
buff, strnlen(buff, sizeof(buff)));
}
static void get_threshold(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
int threshold;
set_default_result(info);
threshold = <API key>(info->client, 0x05);
if (threshold < 0) {
snprintf(buff, sizeof(buff), "%s", "NG");
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 3;
return;
}
snprintf(buff, sizeof(buff), "%d", threshold);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__,
buff, strnlen(buff, sizeof(buff)));
}
/*
static void module_off_master(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[3] = {0};
mutex_lock(&info->lock);
if (info->enabled) {
disable_irq(info->irq);
info->enabled = false;
touch_is_pressed = 0;
}
mutex_unlock(&info->lock);
info->pdata->power(0);
if (info->pdata->is_vdd_on() == 0)
snprintf(buff, sizeof(buff), "%s", "OK");
else
snprintf(buff, sizeof(buff), "%s", "NG");
set_default_result(info);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
if (strncmp(buff, "OK", 2) == 0)
info->cmd_state = 2;
else
info->cmd_state = 3;
dev_info(&info->client->dev, "%s: %s\n", __func__, buff);
}
static void module_on_master(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[3] = {0};
mms_pwr_on_reset(info);
mutex_lock(&info->lock);
if (!info->enabled) {
enable_irq(info->irq);
info->enabled = true;
}
mutex_unlock(&info->lock);
if (info->pdata->is_vdd_on() == 1)
snprintf(buff, sizeof(buff), "%s", "OK");
else
snprintf(buff, sizeof(buff), "%s", "NG");
set_default_result(info);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
if (strncmp(buff, "OK", 2) == 0)
info->cmd_state = 2;
else
info->cmd_state = 3;
dev_info(&info->client->dev, "%s: %s\n", __func__, buff);
}
static void module_off_slave(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
not_support_cmd(info);
}
static void module_on_slave(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
not_support_cmd(info);
}
*/
static void get_chip_vendor(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
set_default_result(info);
snprintf(buff, sizeof(buff), "%s", "MELFAS");
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__,
buff, strnlen(buff, sizeof(buff)));
}
static void get_chip_name(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
set_default_result(info);
snprintf(buff, sizeof(buff), "%s", "MMS144");
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__,
buff, strnlen(buff, sizeof(buff)));
}
static void get_reference(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
unsigned int val;
int node;
set_default_result(info);
node = check_rx_tx_num(info);
if (node < 0)
return;
val = info->reference[node];
snprintf(buff, sizeof(buff), "%u", val);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__,
buff, strnlen(buff, sizeof(buff)));
}
static void get_cm_abs(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
unsigned int val;
int node;
set_default_result(info);
node = check_rx_tx_num(info);
if (node < 0)
return;
val = info->raw[node];
snprintf(buff, sizeof(buff), "%u", val);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__, buff,
strnlen(buff, sizeof(buff)));
}
static void get_cm_delta(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
unsigned int val;
int node;
set_default_result(info);
node = check_rx_tx_num(info);
if (node < 0)
return;
val = info->inspection[node];
snprintf(buff, sizeof(buff), "%u", val);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__, buff,
strnlen(buff, sizeof(buff)));
}
static void get_intensity(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
unsigned int val;
int node;
set_default_result(info);
node = check_rx_tx_num(info);
if (node < 0)
return;
val = info->intensity[node];
snprintf(buff, sizeof(buff), "%u", val);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__, buff,
strnlen(buff, sizeof(buff)));
}
static void get_x_num(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
int val;
set_default_result(info);
val = <API key>(info->client, 0xEF);
if (val < 0) {
snprintf(buff, sizeof(buff), "%s", "NG");
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 3;
dev_info(&info->client->dev,
"%s: fail to read num of x (%d).\n", __func__, val);
return;
}
snprintf(buff, sizeof(buff), "%u", val);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__, buff,
strnlen(buff, sizeof(buff)));
}
static void get_y_num(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
char buff[16] = {0};
int val;
set_default_result(info);
val = <API key>(info->client, 0xEE);
if (val < 0) {
snprintf(buff, sizeof(buff), "%s", "NG");
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 3;
dev_info(&info->client->dev,
"%s: fail to read num of y (%d).\n", __func__, val);
return;
}
snprintf(buff, sizeof(buff), "%u", val);
set_cmd_result(info, buff, strnlen(buff, sizeof(buff)));
info->cmd_state = 2;
dev_info(&info->client->dev, "%s: %s(%d)\n", __func__, buff,
strnlen(buff, sizeof(buff)));
}
static void run_reference_read(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
set_default_result(info);
get_raw_data_all(info, MMS_VSC_CMD_REFER);
info->cmd_state = 2;
/* dev_info(&info->client->dev, "%s: %s(%d)\n", __func__); */
}
static void run_cm_abs_read(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
set_default_result(info);
get_raw_data_all(info, MMS_VSC_CMD_CM_ABS);
get_raw_data_all(info, MMS_VSC_CMD_EXIT);
info->cmd_state = 2;
/* dev_info(&info->client->dev, "%s: %s(%d)\n", __func__); */
}
static void run_cm_delta_read(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
set_default_result(info);
get_raw_data_all(info, <API key>);
get_raw_data_all(info, MMS_VSC_CMD_EXIT);
info->cmd_state = 2;
/* dev_info(&info->client->dev, "%s: %s(%d)\n", __func__); */
}
static void run_intensity_read(void *device_data)
{
struct mms_ts_info *info = (struct mms_ts_info *)device_data;
set_default_result(info);
get_raw_data_all(info, <API key>);
info->cmd_state = 2;
/* dev_info(&info->client->dev, "%s: %s(%d)\n", __func__); */
}
static ssize_t store_cmd(struct device *dev, struct device_attribute
*devattr, const char *buf, size_t count)
{
struct mms_ts_info *info = dev_get_drvdata(dev);
struct i2c_client *client = info->client;
char *cur, *start, *end;
char buff[TSP_CMD_STR_LEN] = {0};
int len, i;
struct tsp_cmd *tsp_cmd_ptr = NULL;
char delim = ',';
bool cmd_found = false;
int param_cnt = 0;
int ret;
if (info->cmd_is_running == true) {
dev_err(&info->client->dev, "tsp_cmd: other cmd is running.\n");
goto err_out;
}
/* check lock */
mutex_lock(&info->cmd_lock);
info->cmd_is_running = true;
mutex_unlock(&info->cmd_lock);
info->cmd_state = 1;
for (i = 0; i < ARRAY_SIZE(info->cmd_param); i++)
info->cmd_param[i] = 0;
len = (int)count;
if (*(buf + len - 1) == '\n')
len
memset(info->cmd, 0x00, ARRAY_SIZE(info->cmd));
memcpy(info->cmd, buf, len);
cur = strchr(buf, (int)delim);
if (cur)
memcpy(buff, buf, cur - buf);
else
memcpy(buff, buf, len);
/* find command */
list_for_each_entry(tsp_cmd_ptr, &info->cmd_list_head, list) {
if (!strcmp(buff, tsp_cmd_ptr->cmd_name)) {
cmd_found = true;
break;
}
}
/* set not_support_cmd */
if (!cmd_found) {
list_for_each_entry(tsp_cmd_ptr, &info->cmd_list_head, list) {
if (!strcmp("not_support_cmd", tsp_cmd_ptr->cmd_name))
break;
}
}
/* parsing parameters */
if (cur && cmd_found) {
cur++;
start = cur;
memset(buff, 0x00, ARRAY_SIZE(buff));
do {
if (*cur == delim || cur - buf == len) {
end = cur;
memcpy(buff, start, end - start);
*(buff + strlen(buff)) = '\0';
ret = kstrtoint(buff, 10,\
info->cmd_param + param_cnt);
start = cur + 1;
memset(buff, 0x00, ARRAY_SIZE(buff));
param_cnt++;
}
cur++;
} while (cur - buf <= len);
}
dev_info(&client->dev, "cmd = %s\n", tsp_cmd_ptr->cmd_name);
for (i = 0; i < param_cnt; i++)
dev_info(&client->dev, "cmd param %d= %d\n", i,
info->cmd_param[i]);
tsp_cmd_ptr->cmd_func(info);
err_out:
return count;
}
static ssize_t show_cmd_status(struct device *dev,
struct device_attribute *devattr, char *buf)
{
struct mms_ts_info *info = dev_get_drvdata(dev);
char buff[16] = {0};
dev_info(&info->client->dev, "tsp cmd: status:%d\n",
info->cmd_state);
if (info->cmd_state == 0)
snprintf(buff, sizeof(buff), "WAITING");
else if (info->cmd_state == 1)
snprintf(buff, sizeof(buff), "RUNNING");
else if (info->cmd_state == 2)
snprintf(buff, sizeof(buff), "OK");
else if (info->cmd_state == 3)
snprintf(buff, sizeof(buff), "FAIL");
else if (info->cmd_state == 4)
snprintf(buff, sizeof(buff), "NOT_APPLICABLE");
return snprintf(buf, TSP_BUF_SIZE, "%s\n", buff);
}
static ssize_t show_cmd_result(struct device *dev, struct device_attribute
*devattr, char *buf)
{
struct mms_ts_info *info = dev_get_drvdata(dev);
dev_info(&info->client->dev, "tsp cmd: result: %s\n", info->cmd_result);
mutex_lock(&info->cmd_lock);
info->cmd_is_running = false;
mutex_unlock(&info->cmd_lock);
info->cmd_state = 0;
return snprintf(buf, TSP_BUF_SIZE, "%s\n", info->cmd_result);
}
#ifdef ESD_DEBUG
static bool intensity_log_flag;
static ssize_t <API key>(struct device *dev,
struct device_attribute *devattr, char *buf)
{
struct mms_ts_info *info = dev_get_drvdata(dev);
struct i2c_client *client = info->client;
struct file *fp;
char log_data[160] = { 0, };
char buff[16] = { 0, };
mm_segment_t old_fs;
long nwrite;
u32 val;
int i, y, c;
old_fs = get_fs();
set_fs(KERNEL_DS);
#define <API key> "/sdcard/melfas_log"
dev_info(&client->dev, "%s: start.\n", __func__);
fp = filp_open(<API key>, O_RDWR | O_CREAT,
S_IRWXU | S_IRWXG | S_IRWXO);
if (IS_ERR(fp)) {
dev_err(&client->dev, "%s: fail to open log file\n", __func__);
goto open_err;
}
intensity_log_flag = 1;
do {
for (y = 0; y < 3; y++) {
/* for tx chanel 0~2 */
memset(log_data, 0x00, 160);
snprintf(buff, 16, "%1u: ", y);
strncat(log_data, buff, strnlen(buff, 16));
for (i = 0; i < RX_NUM; i++) {
val = get_raw_data_one(info, i, y,
<API key>);
snprintf(buff, 16, "%5u, ", val);
strncat(log_data, buff, strnlen(buff, 16));
}
memset(buff, '\n', 2);
c = (y == 2) ? 2 : 1;
strncat(log_data, buff, c);
nwrite = vfs_write(fp, (const char __user *)log_data,
strnlen(log_data, 160), &fp->f_pos);
}
usleep_range(5000);
} while (intensity_log_flag);
filp_close(fp, current->files);
set_fs(old_fs);
return 0;
open_err:
set_fs(old_fs);
return FAIL;
}
static ssize_t <API key>(struct device *dev,
struct device_attribute *devattr, char *buf)
{
struct mms_ts_info *info = dev_get_drvdata(dev);
intensity_log_flag = 0;
usleep_range(10000);
get_raw_data_all(info, MMS_VSC_CMD_EXIT);
return 0;
}
#endif
static DEVICE_ATTR(close_tsp_test, S_IRUGO, show_close_tsp_test, NULL);
static DEVICE_ATTR(cmd, S_IWUSR | S_IWGRP, NULL, store_cmd);
static DEVICE_ATTR(cmd_status, S_IRUGO, show_cmd_status, NULL);
static DEVICE_ATTR(cmd_result, S_IRUGO, show_cmd_result, NULL);
#ifdef ESD_DEBUG
static DEVICE_ATTR(<API key>, S_IRUGO, <API key>,
NULL);
static DEVICE_ATTR(<API key>, S_IRUGO, <API key>,
NULL);
#endif
static struct attribute *<API key>[] = {
&<API key>.attr,
&dev_attr_cmd.attr,
&dev_attr_cmd_status.attr,
&dev_attr_cmd_result.attr,
#ifdef ESD_DEBUG
&<API key>.attr,
&<API key>.attr,
#endif
NULL,
};
static struct attribute_group <API key> = {
.attrs = <API key>,
};
#endif /* <API key> */
static int __devinit mms_ts_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct mms_ts_info *info;
struct input_dev *input_dev;
int ret = 0;
char buf[4] = { 0, };
#ifdef <API key>
int i;
struct device *fac_dev_ts;
#endif
touch_is_pressed = 0;
#if 0
gpio_request(GPIO_OLED_DET, "OLED_DET");
ret = gpio_get_value(GPIO_OLED_DET);
printk(KERN_DEBUG
"[TSP] OLED_DET = %d\n", ret);
if (ret == 0) {
printk(KERN_DEBUG
"[TSP] device wasn't connected to board\n");
return -EIO;
}
#endif
if (!<API key>(adapter, I2C_FUNC_I2C))
return -EIO;
info = kzalloc(sizeof(struct mms_ts_info), GFP_KERNEL);
if (!info) {
dev_err(&client->dev, "Failed to allocate memory\n");
ret = -ENOMEM;
goto err_alloc;
}
input_dev = <API key>();
if (!input_dev) {
dev_err(&client->dev, "Failed to allocate memory for input device\n");
ret = -ENOMEM;
goto err_input_alloc;
}
info->client = client;
info->input_dev = input_dev;
info->pdata = client->dev.platform_data;
if (NULL == info->pdata) {
pr_err("failed to get platform data\n");
goto err_reg_input_dev;
}
info->irq = -1;
mutex_init(&info->lock);
if (info->pdata) {
info->max_x = info->pdata->max_x;
info->max_y = info->pdata->max_y;
info->invert_x = info->pdata->invert_x;
info->invert_y = info->pdata->invert_y;
info->config_fw_version = info->pdata->config_fw_version;
info->register_cb = info->pdata->register_cb;
} else {
info->max_x = 720;
info->max_y = 1280;
}
snprintf(info->phys, sizeof(info->phys),
"%s/input0", dev_name(&client->dev));
input_dev->name = "sec_touchscreen"; /*= "Melfas MMSxxx Touchscreen";*/
input_dev->phys = info->phys;
input_dev->id.bustype = BUS_I2C;
input_dev->dev.parent = &client->dev;
__set_bit(EV_ABS, input_dev->evbit);
__set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
input_mt_init_slots(input_dev, MAX_FINGERS);
<API key>(input_dev, ABS_MT_WIDTH_MAJOR,
0, MAX_WIDTH, 0, 0);
<API key>(input_dev, ABS_MT_POSITION_X,
0, (info->max_x)-1, 0, 0);
<API key>(input_dev, ABS_MT_POSITION_Y,
0, (info->max_y)-1, 0, 0);
<API key>(input_dev, ABS_MT_TOUCH_MAJOR,
0, MAX_PRESSURE, 0, 0);
<API key>(input_dev, ABS_MT_TOUCH_MINOR,
0, MAX_PRESSURE, 0, 0);
<API key>(input_dev, ABS_MT_ANGLE,
MIN_ANGLE, MAX_ANGLE, 0, 0);
<API key>(input_dev, ABS_MT_PALM,
0, 1, 0, 0);
input_set_drvdata(input_dev, info);
ret = <API key>(input_dev);
if (ret) {
dev_err(&client->dev, "failed to register input dev (%d)\n",
ret);
goto err_reg_input_dev;
}
#if TOUCH_BOOSTER
mutex_init(&info->dvfs_lock);
INIT_DELAYED_WORK(&info->work_dvfs_off, set_dvfs_off);
INIT_DELAYED_WORK(&info->work_dvfs_chg, change_dvfs_lock);
bus_dev = dev_get("exynos-busfreq");
info->cpufreq_level = -1;
info->dvfs_lock_status = false;
#endif
i2c_set_clientdata(client, info);
info->pdata->power(true);
msleep(100);
ret = i2c_master_recv(client, buf, 1);
if (ret < 0) { /* tsp connect check */
pr_err("%s: i2c fail...tsp driver unload [%d], Add[%d]\n",
__func__, ret, info->client->addr);
goto err_config;
}
ret = mms_ts_fw_load(info);
/* ret = mms_ts_fw_info(info); */
if (ret) {
dev_err(&client->dev, "failed to initialize (%d)\n", ret);
goto err_config;
}
info->enabled = true;
info->callbacks.inform_charger = melfas_ta_cb;
if (info->register_cb)
info->register_cb(&info->callbacks);
#ifdef <API key>
info->early_suspend.level = <API key> + 1;
info->early_suspend.suspend = <API key>;
info->early_suspend.resume = mms_ts_late_resume;
<API key>(&info->early_suspend);
#endif
sec_touchscreen = device_create(sec_class,
NULL, 0, info, "sec_touchscreen");
if (IS_ERR(sec_touchscreen)) {
dev_err(&client->dev,
"Failed to create device for the sysfs1\n");
ret = -ENODEV;
}
#ifdef <API key>
INIT_LIST_HEAD(&info->cmd_list_head);
for (i = 0; i < ARRAY_SIZE(tsp_cmds); i++)
list_add_tail(&tsp_cmds[i].list, &info->cmd_list_head);
mutex_init(&info->cmd_lock);
info->cmd_is_running = false;
fac_dev_ts = device_create(sec_class,
NULL, 0, info, "tsp");
if (IS_ERR(fac_dev_ts))
dev_err(&client->dev, "Failed to create device for the sysfs\n");
ret = sysfs_create_group(&fac_dev_ts->kobj,
&<API key>);
if (ret)
dev_err(&client->dev, "Failed to create sysfs group\n");
#endif
return 0;
err_config:
<API key>(input_dev);
err_reg_input_dev:
input_free_device(input_dev);
err_input_alloc:
input_dev = NULL;
kfree(info);
err_alloc:
return ret;
}
static int __devexit mms_ts_remove(struct i2c_client *client)
{
struct mms_ts_info *info = i2c_get_clientdata(client);
<API key>(&info->early_suspend);
if (info->irq >= 0)
free_irq(info->irq, info);
<API key>(info->input_dev);
kfree(info);
return 0;
}
#if defined(CONFIG_PM) || defined(<API key>)
static int mms_ts_suspend(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct mms_ts_info *info = i2c_get_clientdata(client);
if (!info->enabled)
return 0;
dev_notice(&info->client->dev, "%s: users=%d\n", __func__,
info->input_dev->users);
disable_irq(info->irq);
info->enabled = false;
touch_is_pressed = 0;
release_all_fingers(info);
info->pdata->power(false);
/* This delay needs to prevent unstable POR by
rapid frequently pressing of PWR key. */
msleep(50);
return 0;
}
static int mms_ts_resume(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct mms_ts_info *info = i2c_get_clientdata(client);
int ret = 0;
if (info->enabled)
return 0;
dev_notice(&info->client->dev, "%s: users=%d\n", __func__,
info->input_dev->users);
info->pdata->power(true);
msleep(120);
if (info->ta_status) {
dev_notice(&client->dev, "TA connect!!!\n");
<API key>(info->client, 0x33, 0x1);
} else {
dev_notice(&client->dev, "TA disconnect!!!\n");
<API key>(info->client, 0x33, 0x2);
}
/* Because irq_type by EXT_INTxCON register is changed to low_level
* after wakeup, irq_type set to falling edge interrupt again.
*/
enable_irq(info->irq);
info->enabled = true;
mms_set_noise_mode(info);
return 0;
}
#endif
#ifdef <API key>
static void <API key>(struct early_suspend *h)
{
struct mms_ts_info *info;
info = container_of(h, struct mms_ts_info, early_suspend);
mms_ts_suspend(&info->client->dev);
}
static void mms_ts_late_resume(struct early_suspend *h)
{
struct mms_ts_info *info;
info = container_of(h, struct mms_ts_info, early_suspend);
mms_ts_resume(&info->client->dev);
}
#endif
#if defined(CONFIG_PM) && !defined(<API key>)
static const struct dev_pm_ops mms_ts_pm_ops = {
.suspend = mms_ts_suspend,
.resume = mms_ts_resume,
#ifdef CONFIG_HIBERNATION
.freeze = mms_ts_suspend,
.thaw = mms_ts_resume,
.restore = mms_ts_resume,
#endif
};
#endif
static const struct i2c_device_id mms_ts_id[] = {
{MELFAS_TS_NAME, 0},
{}
};
MODULE_DEVICE_TABLE(i2c, mms_ts_id);
static struct i2c_driver mms_ts_driver = {
.probe = mms_ts_probe,
.remove = __devexit_p(mms_ts_remove),
.driver = {
.name = MELFAS_TS_NAME,
#if defined(CONFIG_PM) && !defined(<API key>)
.pm = &mms_ts_pm_ops,
#endif
},
.id_table = mms_ts_id,
};
static int __init mms_ts_init(void)
{
return i2c_add_driver(&mms_ts_driver);
}
static void __exit mms_ts_exit(void)
{
i2c_del_driver(&mms_ts_driver);
}
module_init(mms_ts_init);
module_exit(mms_ts_exit);
/* Module information */
MODULE_DESCRIPTION("Touchscreen driver for Melfas MMS-series controllers");
MODULE_LICENSE("GPL");
|
<html lang="en">
<head>
<title>Expressions - Using as</title>
<meta http-equiv="Content-Type" content="text/html">
<meta name="description" content="Using as">
<meta name="generator" content="makeinfo 4.8">
<link title="Top" rel="start" href="index.html#Top">
<link rel="prev" href="Symbols.html#Symbols" title="Symbols">
<link rel="next" href="Pseudo-Ops.html#Pseudo-Ops" title="Pseudo Ops">
<link href="http:
<!
This file documents the GNU Assembler "as".
Copyright (C) 1991-2018 Free Software Foundation, Inc.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3
or any later version published by the Free Software Foundation;
with no Invariant Sections, with no Front-Cover Texts, and with no
Back-Cover Texts. A copy of the license is included in the
section entitled ``GNU Free Documentation License''.
<meta http-equiv="Content-Style-Type" content="text/css">
<style type="text/css"><!
pre.display { font-family:inherit }
pre.format { font-family:inherit }
pre.smalldisplay { font-family:inherit; font-size:smaller }
pre.smallformat { font-family:inherit; font-size:smaller }
pre.smallexample { font-size:smaller }
pre.smalllisp { font-size:smaller }
span.sc { font-variant:small-caps }
span.roman { font-family:serif; font-weight:normal; }
span.sansserif { font-family:sans-serif; font-weight:normal; }
--></style>
</head>
<body>
<div class="node">
<p>
<a name="Expressions"></a>
Next: <a rel="next" accesskey="n" href="Pseudo-Ops.html#Pseudo-Ops">Pseudo Ops</a>,
Previous: <a rel="previous" accesskey="p" href="Symbols.html#Symbols">Symbols</a>,
Up: <a rel="up" accesskey="u" href="index.html#Top">Top</a>
<hr>
</div>
<h2 class="chapter">6 Expressions</h2>
<p><a name="<API key>"></a><a name="index-addresses-244"></a><a name="<API key>"></a>An <dfn>expression</dfn> specifies an address or numeric value.
Whitespace may precede and/or follow an expression.
<p>The result of an expression must be an absolute number, or else an offset into
a particular section. If an expression is not absolute, and there is not
enough information when <samp><span class="command">as</span></samp> sees the expression to know its
section, a second pass over the source program might be necessary to interpret
the expression—but the second pass is currently not implemented.
<samp><span class="command">as</span></samp> aborts with an error message in this situation.
<ul class="menu">
<li><a accesskey="1" href="Empty-Exprs.html#Empty-Exprs">Empty Exprs</a>: Empty Expressions
<li><a accesskey="2" href="Integer-Exprs.html#Integer-Exprs">Integer Exprs</a>: Integer Expressions
</ul>
</body></html>
|
#userIcon.hear {
-fx-image: url(../img/eye.png);
}
#userIcon.me {
-fx-image: url(../img/eye.png);
-fx-opacity: 0.1;
}
#userIcon.me:hover {
-fx-image: url(../img/eye.png);
-fx-opacity: 0.3;
}
#userIcon.master {
-fx-image: url(../img/crown.png);
}
#userItem {
-fx-background-color: #E4F6F9;
-<API key>: 10;
}
Label {
-fx-text-fill: #8EBDC4;
}
|
#!/bin/sh
# modify, copy, or redistribute it subject to the terms and conditions
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
. lib/inittest
test -e LOCAL_LVMETAD || skip
aux prepare_devs 2
pvcreate --metadatatype 1 "$dev1"
should vgscan --cache
pvs | should grep "$dev1"
vgcreate --metadatatype 1 $vg1 "$dev1"
should vgscan --cache
vgs | should grep $vg1
pvs | should grep "$dev1"
# check for RHBZ 1080189 -- SEGV in lvremove/vgremove
pvcreate -ff -y --metadatatype 1 "$dev1" "$dev2"
vgcreate --metadatatype 1 $vg1 "$dev1" "$dev2"
lvcreate -l1 $vg1
pvremove -ff -y "$dev2"
vgchange -an $vg1
not lvremove $vg1
not vgremove -ff -y $vg1
|
#ifndef VIDEO_HPP_INCLUDED
#define VIDEO_HPP_INCLUDED
#include "events.hpp"
#include "exceptions.hpp"
#include "<API key>.hpp"
#include <boost/utility.hpp>
struct surface;
//possible flags when setting video modes
#define FULL_SCREEN SDL_FULLSCREEN
surface <API key>(surface surf);
surface get_video_surface();
SDL_Rect screen_area();
bool non_interactive();
//which areas of the screen will be updated when the buffer is flipped?
void update_rect(size_t x, size_t y, size_t w, size_t h);
void update_rect(const SDL_Rect& rect);
void update_whole_screen();
class CVideo : private boost::noncopyable {
public:
enum FAKE_TYPES {
NO_FAKE,
FAKE,
FAKE_TEST
};
CVideo(FAKE_TYPES type = NO_FAKE);
~CVideo();
int bppForMode( int x, int y, int flags);
int modePossible( int x, int y, int bits_per_pixel, int flags, bool <API key>=false);
int setMode( int x, int y, int bits_per_pixel, int flags );
//did the mode change, since the last call to the modeChanged() method?
bool modeChanged();
//functions to get the dimensions of the current video-mode
int getx() const;
int gety() const;
//blits a surface with black as alpha
void blit_surface(int x, int y, surface surf, SDL_Rect* srcrect=NULL, SDL_Rect* clip_rect=NULL);
void flip();
surface& getSurface();
bool isFullScreen() const;
struct error : public game::error
{
error() : game::error("Video initialization failed") {}
};
class quit
: public <API key>
{
public:
quit()
: <API key>()
{
}
private:
<API key>(quit)
};
//functions to allow changing video modes when 16BPP is emulated
void setBpp( int bpp );
int getBpp();
void make_fake();
/**
* Creates a fake frame buffer for the unit tests.
*
* @param width The width of the buffer.
* @param height The height of the buffer.
* @param bpp The bpp of the buffer.
*/
void make_test_fake(const unsigned width = 1024,
const unsigned height = 768, const unsigned bpp = 32);
bool faked() const { return fake_screen_; }
//functions to set and clear 'help strings'. A 'help string' is like a tooltip, but it appears
//at the bottom of the screen, so as to not be intrusive. Setting a help string sets what
//is currently displayed there.
int set_help_string(const std::string& str);
void clear_help_string(int handle);
void <API key>();
//function to stop the screen being redrawn. Anything that happens while
//the update is locked will be hidden from the user's view.
//note that this function is re-entrant, meaning that if lock_updates(true)
//is called twice, lock_updates(false) must be called twice to unlock
//updates.
void lock_updates(bool value);
bool update_locked() const;
private:
void initSDL();
bool mode_changed_;
int bpp_; // Store real bits per pixel
//if there is no display at all, but we 'fake' it for clients
bool fake_screen_;
//variables for help strings
int help_string_;
int updatesLocked_;
};
//an object which will lock the display for the duration of its lifetime.
struct update_locker
{
update_locker(CVideo& v, bool lock=true) : video(v), unlock(lock) {
if(lock) {
video.lock_updates(true);
}
}
~update_locker() {
unlock_update();
}
void unlock_update() {
if(unlock) {
video.lock_updates(false);
unlock = false;
}
}
private:
CVideo& video;
bool unlock;
};
class resize_monitor : public events::pump_monitor {
void process(events::pump_info &info);
};
//an object which prevents resizing of the screen occurring during
//its lifetime.
struct resize_lock {
resize_lock();
~resize_lock();
};
#endif
|
#include <linux/slab.h>
#include <linux/poll.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/jhash.h>
#include <linux/init.h>
#include <linux/futex.h>
#include <linux/mount.h>
#include <linux/pagemap.h>
#include <linux/syscalls.h>
#include <linux/signal.h>
#include <linux/export.h>
#include <linux/magic.h>
#include <linux/pid.h>
#include <linux/nsproxy.h>
#include <linux/ptrace.h>
#include <linux/sched/rt.h>
#include <linux/freezer.h>
#include <linux/hugetlb.h>
#include <asm/futex.h>
#include "rtmutex_common.h"
#ifndef <API key>
int __read_mostly <API key>;
#endif
#define FUTEX_HASHBITS (CONFIG_BASE_SMALL ? 4 : 8)
/*
* Futex flags used to encode options to functions and preserve them across
* restarts.
*/
#define FLAGS_SHARED 0x01
#define FLAGS_CLOCKRT 0x02
#define FLAGS_HAS_TIMEOUT 0x04
/*
* Priority Inheritance state:
*/
struct futex_pi_state {
/*
* list of 'owned' pi_state instances - these have to be
* cleaned up in do_exit() if the task exits prematurely:
*/
struct list_head list;
/*
* The PI object:
*/
struct rt_mutex pi_mutex;
struct task_struct *owner;
atomic_t refcount;
union futex_key key;
};
/**
* struct futex_q - The hashed futex queue entry, one per waiting task
* @list: priority-sorted list of tasks waiting on this futex
* @task: the task waiting on the futex
* @lock_ptr: the hash bucket lock
* @key: the key the futex is hashed on
* @pi_state: optional priority inheritance state
* @rt_waiter: rt_waiter storage for use with requeue_pi
* @requeue_pi_key: the requeue_pi target futex key
* @bitset: bitset for the optional bitmasked wakeup
*
* We use this hashed waitqueue, instead of a normal wait_queue_t, so
* we can wake only the relevant ones (hashed queues may be shared).
*
* A futex_q has a woken state, just like tasks have TASK_RUNNING.
* It is considered woken when plist_node_empty(&q->list) || q->lock_ptr == 0.
* The order of wakeup is always to make the first condition true, then
* the second.
*
* PI futexes are typically woken before they are removed from the hash list via
* the rt_mutex code. See unqueue_me_pi().
*/
struct futex_q {
struct plist_node list;
struct task_struct *task;
spinlock_t *lock_ptr;
union futex_key key;
struct futex_pi_state *pi_state;
struct rt_mutex_waiter *rt_waiter;
union futex_key *requeue_pi_key;
u32 bitset;
};
static const struct futex_q futex_q_init = {
/* list gets initialized in queue_me()*/
.key = FUTEX_KEY_INIT,
.bitset = <API key>
};
/*
* Hash buckets are shared by all the futex_keys that hash to the same
* location. Each key may have multiple futex_q structures, one for each task
* waiting on a futex.
*/
struct futex_hash_bucket {
spinlock_t lock;
struct plist_head chain;
};
static struct futex_hash_bucket futex_queues[1<<FUTEX_HASHBITS];
/*
* We hash on the keys returned from get_futex_key (see below).
*/
static struct futex_hash_bucket *hash_futex(union futex_key *key)
{
u32 hash = jhash2((u32*)&key->both.word,
(sizeof(key->both.word)+sizeof(key->both.ptr))/4,
key->both.offset);
return &futex_queues[hash & ((1 << FUTEX_HASHBITS)-1)];
}
/*
* Return 1 if two futex_keys are equal, 0 otherwise.
*/
static inline int match_futex(union futex_key *key1, union futex_key *key2)
{
return (key1 && key2
&& key1->both.word == key2->both.word
&& key1->both.ptr == key2->both.ptr
&& key1->both.offset == key2->both.offset);
}
/*
* Take a reference to the resource addressed by a key.
* Can be called while holding spinlocks.
*
*/
static void get_futex_key_refs(union futex_key *key)
{
if (!key->both.ptr)
return;
switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
case FUT_OFF_INODE:
ihold(key->shared.inode);
break;
case FUT_OFF_MMSHARED:
atomic_inc(&key->private.mm->mm_count);
break;
}
}
/*
* Drop a reference to the resource addressed by a key.
* The hash bucket spinlock must not be held.
*/
static void drop_futex_key_refs(union futex_key *key)
{
if (!key->both.ptr) {
/* If we're here then we tried to put a key we failed to get */
WARN_ON_ONCE(1);
return;
}
switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
case FUT_OFF_INODE:
iput(key->shared.inode);
break;
case FUT_OFF_MMSHARED:
mmdrop(key->private.mm);
break;
}
}
/**
* get_futex_key() - Get parameters which are the keys for a futex
* @uaddr: virtual address of the futex
* @fshared: 0 for a PROCESS_PRIVATE futex, 1 for PROCESS_SHARED
* @key: address where result is stored.
* @rw: mapping needs to be read/write (values: VERIFY_READ,
* VERIFY_WRITE)
*
* Return: a negative error code or 0
*
* The key words are stored in *key on success.
*
* For shared mappings, it's (page->index, file_inode(vma->vm_file),
* offset_within_page). For private mappings, it's (uaddr, current->mm).
* We can usually work out the index without swapping in the page.
*
* lock_page() might sleep, the caller should not hold a spinlock.
*/
static int
get_futex_key(u32 __user *uaddr, int fshared, union futex_key *key, int rw)
{
unsigned long address = (unsigned long)uaddr;
struct mm_struct *mm = current->mm;
struct page *page, *page_head;
int err, ro = 0;
/*
* The futex address must be "naturally" aligned.
*/
key->both.offset = address % PAGE_SIZE;
if (unlikely((address % sizeof(u32)) != 0))
return -EINVAL;
address -= key->both.offset;
/*
* PROCESS_PRIVATE futexes are fast.
* As the mm cannot disappear under us and the 'key' only needs
* virtual address, we dont even have to find the underlying vma.
* Note : We do have to check 'uaddr' is a valid user address,
* but access_ok() should be faster than find_vma()
*/
if (!fshared) {
if (unlikely(!access_ok(VERIFY_WRITE, uaddr, sizeof(u32))))
return -EFAULT;
key->private.mm = mm;
key->private.address = address;
get_futex_key_refs(key);
return 0;
}
again:
err = get_user_pages_fast(address, 1, 1, &page);
/*
* If write access is not required (eg. FUTEX_WAIT), try
* and get read-only access.
*/
if (err == -EFAULT && rw == VERIFY_READ) {
err = get_user_pages_fast(address, 1, 0, &page);
ro = 1;
}
if (err < 0)
return err;
else
err = 0;
#ifdef <API key>
page_head = page;
if (unlikely(PageTail(page))) {
put_page(page);
/* serialize against <API key>() */
local_irq_disable();
if (likely(<API key>(address, 1, !ro, &page) == 1)) {
page_head = compound_head(page);
/*
* page_head is valid pointer but we must pin
* it before taking the PG_lock and/or
* PG_compound_lock. The moment we re-enable
* irqs <API key>() can
* return and the head page can be freed from
* under us. We can't take the PG_lock and/or
* PG_compound_lock on a page that could be
* freed from under us.
*/
if (page != page_head) {
get_page(page_head);
put_page(page);
}
local_irq_enable();
} else {
local_irq_enable();
goto again;
}
}
#else
page_head = compound_head(page);
if (page != page_head) {
get_page(page_head);
put_page(page);
}
#endif
lock_page(page_head);
/*
* If page_head->mapping is NULL, then it cannot be a PageAnon
* page; but it might be the ZERO_PAGE or in the gate area or
* in a special mapping (all cases which we are happy to fail);
* or it may have been a good file page when get_user_pages_fast
* found it, but truncated or holepunched or subjected to
* <API key> before we got the page lock (also
* cases which we are happy to fail). And we hold a reference,
* so refcount care in <API key>'s remove_mapping
* prevents drop_caches from setting mapping to NULL beneath us.
*
* The case we do have to guard against is when memory pressure made
* shmem_writepage move it from filecache to swapcache beneath us:
* an unlikely race, but we do need to retry for page_head->mapping.
*/
if (!page_head->mapping) {
int shmem_swizzled = PageSwapCache(page_head);
unlock_page(page_head);
put_page(page_head);
if (shmem_swizzled)
goto again;
return -EFAULT;
}
/*
* Private mappings are handled in a simple way.
*
* NOTE: When userspace waits on a MAP_SHARED mapping, even if
* it's a read-only handle, it's expected that futexes attach to
* the object not the particular process.
*/
if (PageAnon(page_head)) {
/*
* A RO anonymous page will never change and thus doesn't make
* sense for futex operations.
*/
if (ro) {
err = -EFAULT;
goto out;
}
key->both.offset |= FUT_OFF_MMSHARED; /* ref taken on mm */
key->private.mm = mm;
key->private.address = address;
} else {
key->both.offset |= FUT_OFF_INODE; /* inode-based key */
key->shared.inode = page_head->mapping->host;
key->shared.pgoff = basepage_index(page);
}
get_futex_key_refs(key);
out:
unlock_page(page_head);
put_page(page_head);
return err;
}
static inline void put_futex_key(union futex_key *key)
{
drop_futex_key_refs(key);
}
/**
* <API key>() - Fault in user address and verify RW access
* @uaddr: pointer to faulting user space address
*
* Slow path to fixup the fault we just took in the atomic write
* access to @uaddr.
*
* We have no generic implementation of a non-destructive write to the
* user address. We know that we faulted in the atomic pagefault
* disabled section so we can as well avoid the #PF overhead by
* calling get_user_pages() right away.
*/
static int <API key>(u32 __user *uaddr)
{
struct mm_struct *mm = current->mm;
int ret;
down_read(&mm->mmap_sem);
ret = fixup_user_fault(current, mm, (unsigned long)uaddr,
FAULT_FLAG_WRITE);
up_read(&mm->mmap_sem);
return ret < 0 ? ret : 0;
}
/**
* futex_top_waiter() - Return the highest priority waiter on a futex
* @hb: the hash bucket the futex_q's reside in
* @key: the futex key (to distinguish it from other futex futex_q's)
*
* Must be called with the hb lock held.
*/
static struct futex_q *futex_top_waiter(struct futex_hash_bucket *hb,
union futex_key *key)
{
struct futex_q *this;
<API key>(this, &hb->chain, list) {
if (match_futex(&this->key, key))
return this;
}
return NULL;
}
static int <API key>(u32 *curval, u32 __user *uaddr,
u32 uval, u32 newval)
{
int ret;
pagefault_disable();
ret = <API key>(curval, uaddr, uval, newval);
pagefault_enable();
return ret;
}
static int <API key>(u32 *dest, u32 __user *from)
{
int ret;
pagefault_disable();
ret = <API key>(dest, from, sizeof(u32));
pagefault_enable();
return ret ? -EFAULT : 0;
}
/*
* PI code:
*/
static int <API key>(void)
{
struct futex_pi_state *pi_state;
if (likely(current->pi_state_cache))
return 0;
pi_state = kzalloc(sizeof(*pi_state), GFP_KERNEL);
if (!pi_state)
return -ENOMEM;
INIT_LIST_HEAD(&pi_state->list);
/* pi_mutex gets initialized later */
pi_state->owner = NULL;
atomic_set(&pi_state->refcount, 1);
pi_state->key = FUTEX_KEY_INIT;
current->pi_state_cache = pi_state;
return 0;
}
static struct futex_pi_state * alloc_pi_state(void)
{
struct futex_pi_state *pi_state = current->pi_state_cache;
WARN_ON(!pi_state);
current->pi_state_cache = NULL;
return pi_state;
}
static void free_pi_state(struct futex_pi_state *pi_state)
{
if (!atomic_dec_and_test(&pi_state->refcount))
return;
/*
* If pi_state->owner is NULL, the owner is most probably dying
* and has cleaned up the pi_state already
*/
if (pi_state->owner) {
raw_spin_lock_irq(&pi_state->owner->pi_lock);
list_del_init(&pi_state->list);
raw_spin_unlock_irq(&pi_state->owner->pi_lock);
<API key>(&pi_state->pi_mutex, pi_state->owner);
}
if (current->pi_state_cache)
kfree(pi_state);
else {
/*
* pi_state->list is already empty.
* clear pi_state->owner.
* refcount is at 0 - put it back to 1.
*/
pi_state->owner = NULL;
atomic_set(&pi_state->refcount, 1);
current->pi_state_cache = pi_state;
}
}
/*
* Look up the task based on what TID userspace gave us.
* We dont trust it.
*/
static struct task_struct * futex_find_get_task(pid_t pid)
{
struct task_struct *p;
rcu_read_lock();
p = find_task_by_vpid(pid);
if (p)
get_task_struct(p);
rcu_read_unlock();
return p;
}
/*
* This task is holding PI mutexes at exit time => bad.
* Kernel cleans up PI-state, but userspace is likely hosed.
* (Robust-futex cleanup is separate and might save the day for userspace.)
*/
void exit_pi_state_list(struct task_struct *curr)
{
struct list_head *next, *head = &curr->pi_state_list;
struct futex_pi_state *pi_state;
struct futex_hash_bucket *hb;
union futex_key key = FUTEX_KEY_INIT;
if (!<API key>)
return;
/*
* We are a ZOMBIE and nobody can enqueue itself on
* pi_state_list anymore, but we have to be careful
* versus waiters unqueueing themselves:
*/
raw_spin_lock_irq(&curr->pi_lock);
while (!list_empty(head)) {
next = head->next;
pi_state = list_entry(next, struct futex_pi_state, list);
key = pi_state->key;
hb = hash_futex(&key);
raw_spin_unlock_irq(&curr->pi_lock);
spin_lock(&hb->lock);
raw_spin_lock_irq(&curr->pi_lock);
/*
* We dropped the pi-lock, so re-check whether this
* task still owns the PI-state:
*/
if (head->next != next) {
spin_unlock(&hb->lock);
continue;
}
WARN_ON(pi_state->owner != curr);
WARN_ON(list_empty(&pi_state->list));
list_del_init(&pi_state->list);
pi_state->owner = NULL;
raw_spin_unlock_irq(&curr->pi_lock);
rt_mutex_unlock(&pi_state->pi_mutex);
spin_unlock(&hb->lock);
raw_spin_lock_irq(&curr->pi_lock);
}
raw_spin_unlock_irq(&curr->pi_lock);
}
static int
lookup_pi_state(u32 uval, struct futex_hash_bucket *hb,
union futex_key *key, struct futex_pi_state **ps)
{
struct futex_pi_state *pi_state = NULL;
struct futex_q *this, *next;
struct plist_head *head;
struct task_struct *p;
pid_t pid = uval & FUTEX_TID_MASK;
head = &hb->chain;
<API key>(this, next, head, list) {
if (match_futex(&this->key, key)) {
/*
* Sanity check the waiter before increasing
* the refcount and attaching to it.
*/
pi_state = this->pi_state;
/*
* Userspace might have messed up non-PI and
* PI futexes [3]
*/
if (unlikely(!pi_state))
return -EINVAL;
WARN_ON(!atomic_read(&pi_state->refcount));
/*
* Handle the owner died case:
*/
if (uval & FUTEX_OWNER_DIED) {
/*
* exit_pi_state_list sets owner to NULL and
* wakes the topmost waiter. The task which
* acquires the pi_state->rt_mutex will fixup
* owner.
*/
if (!pi_state->owner) {
/*
* No pi state owner, but the user
* space TID is not 0. Inconsistent
* state. [5]
*/
if (pid)
return -EINVAL;
/*
* Take a ref on the state and
* return. [4]
*/
goto out_state;
}
/*
* If TID is 0, then either the dying owner
* has not yet executed exit_pi_state_list()
* or some waiter acquired the rtmutex in the
* pi state, but did not yet fixup the TID in
* user space.
*
* Take a ref on the state and return. [6]
*/
if (!pid)
goto out_state;
} else {
/*
* If the owner died bit is not set,
* then the pi_state must have an
* owner. [7]
*/
if (!pi_state->owner)
return -EINVAL;
}
/*
* Bail out if user space manipulated the
* futex value. If pi state exists then the
* owner TID must be the same as the user
* space TID. [9/10]
*/
if (pid != task_pid_vnr(pi_state->owner))
return -EINVAL;
out_state:
atomic_inc(&pi_state->refcount);
*ps = pi_state;
return 0;
}
}
/*
* We are the first waiter - try to look up the real owner and attach
* the new pi_state to it, but bail out when TID = 0 [1]
*/
if (!pid)
return -ESRCH;
p = futex_find_get_task(pid);
if (!p)
return -ESRCH;
if (!p->mm) {
put_task_struct(p);
return -EPERM;
}
/*
* We need to look at the task state flags to figure out,
* whether the task is exiting. To protect against the do_exit
* change of the task flags, we do this protected by
* p->pi_lock:
*/
raw_spin_lock_irq(&p->pi_lock);
if (unlikely(p->flags & PF_EXITING)) {
/*
* The task is on the way out. When PF_EXITPIDONE is
* set, we know that the task has finished the
* cleanup:
*/
int ret = (p->flags & PF_EXITPIDONE) ? -ESRCH : -EAGAIN;
raw_spin_unlock_irq(&p->pi_lock);
put_task_struct(p);
return ret;
}
/*
* No existing pi state. First waiter. [2]
*/
pi_state = alloc_pi_state();
/*
* Initialize the pi_mutex in locked state and make 'p'
* the owner of it:
*/
<API key>(&pi_state->pi_mutex, p);
/* Store the key for possible exit cleanups: */
pi_state->key = *key;
WARN_ON(!list_empty(&pi_state->list));
list_add(&pi_state->list, &p->pi_state_list);
pi_state->owner = p;
raw_spin_unlock_irq(&p->pi_lock);
put_task_struct(p);
*ps = pi_state;
return 0;
}
/**
* <API key>() - Atomic work required to acquire a pi aware futex
* @uaddr: the pi futex user address
* @hb: the pi futex hash bucket
* @key: the futex key associated with uaddr and hb
* @ps: the pi_state pointer where we store the result of the
* lookup
* @task: the task to perform the atomic lock work for. This will
* be "current" except in the case of requeue pi.
* @set_waiters: force setting the FUTEX_WAITERS bit (1) or not (0)
*
* Return:
* 0 - ready to wait;
* 1 - acquired the lock;
* <0 - error
*
* The hb->lock and futex_key refs shall be held by the caller.
*/
static int <API key>(u32 __user *uaddr, struct futex_hash_bucket *hb,
union futex_key *key,
struct futex_pi_state **ps,
struct task_struct *task, int set_waiters)
{
int lock_taken, ret, force_take = 0;
u32 uval, newval, curval, vpid = task_pid_vnr(task);
retry:
ret = lock_taken = 0;
/*
* To avoid races, we attempt to take the lock here again
* (by doing a 0 -> TID atomic cmpxchg), while holding all
* the locks. It will most likely not succeed.
*/
newval = vpid;
if (set_waiters)
newval |= FUTEX_WAITERS;
if (unlikely(<API key>(&curval, uaddr, 0, newval)))
return -EFAULT;
/*
* Detect deadlocks.
*/
if ((unlikely((curval & FUTEX_TID_MASK) == vpid)))
return -EDEADLK;
/*
* Surprise - we got the lock, but we do not trust user space at all.
*/
if (unlikely(!curval)) {
/*
* We verify whether there is kernel state for this
* futex. If not, we can safely assume, that the 0 ->
* TID transition is correct. If state exists, we do
* not bother to fixup the user space state as it was
* corrupted already.
*/
return futex_top_waiter(hb, key) ? -EINVAL : 1;
}
uval = curval;
/*
* Set the FUTEX_WAITERS flag, so the owner will know it has someone
* to wake at the next unlock.
*/
newval = curval | FUTEX_WAITERS;
/*
* Should we force take the futex? See below.
*/
if (unlikely(force_take)) {
/*
* Keep the OWNER_DIED and the WAITERS bit and set the
* new TID value.
*/
newval = (curval & ~FUTEX_TID_MASK) | vpid;
force_take = 0;
lock_taken = 1;
}
if (unlikely(<API key>(&curval, uaddr, uval, newval)))
return -EFAULT;
if (unlikely(curval != uval))
goto retry;
/*
* We took the lock due to forced take over.
*/
if (unlikely(lock_taken))
return 1;
/*
* We dont have the lock. Look up the PI state (or create it if
* we are the first waiter):
*/
ret = lookup_pi_state(uval, hb, key, ps);
if (unlikely(ret)) {
switch (ret) {
case -ESRCH:
/*
* We failed to find an owner for this
* futex. So we have no pi_state to block
* on. This can happen in two cases:
*
* 1) The owner died
* 2) A stale FUTEX_WAITERS bit
*
* Re-read the futex value.
*/
if (<API key>(&curval, uaddr))
return -EFAULT;
/*
* If the owner died or we have a stale
* WAITERS bit the owner TID in the user space
* futex is 0.
*/
if (!(curval & FUTEX_TID_MASK)) {
force_take = 1;
goto retry;
}
default:
break;
}
}
return ret;
}
/**
* __unqueue_futex() - Remove the futex_q from its futex_hash_bucket
* @q: The futex_q to unqueue
*
* The q->lock_ptr must not be NULL and must be held by the caller.
*/
static void __unqueue_futex(struct futex_q *q)
{
struct futex_hash_bucket *hb;
if (WARN_ON_SMP(!q->lock_ptr || !spin_is_locked(q->lock_ptr))
|| WARN_ON(plist_node_empty(&q->list)))
return;
hb = container_of(q->lock_ptr, struct futex_hash_bucket, lock);
plist_del(&q->list, &hb->chain);
}
/*
* The hash bucket lock must be held when this is called.
* Afterwards, the futex_q must not be accessed.
*/
static void wake_futex(struct futex_q *q)
{
struct task_struct *p = q->task;
if (WARN(q->pi_state || q->rt_waiter, "refusing to wake PI futex\n"))
return;
/*
* We set q->lock_ptr = NULL _before_ we wake up the task. If
* a non-futex wake up happens on another CPU then the task
* might exit and p would dereference a non-existing task
* struct. Prevent this by holding a reference on p across the
* wake up.
*/
get_task_struct(p);
__unqueue_futex(q);
/*
* The waiting task can free the futex_q as soon as
* q->lock_ptr = NULL is written, without taking any locks. A
* memory barrier is required here to prevent the following
* store to lock_ptr from getting ahead of the plist_del.
*/
smp_wmb();
q->lock_ptr = NULL;
wake_up_state(p, TASK_NORMAL);
put_task_struct(p);
}
static int wake_futex_pi(u32 __user *uaddr, u32 uval, struct futex_q *this)
{
struct task_struct *new_owner;
struct futex_pi_state *pi_state = this->pi_state;
u32 uninitialized_var(curval), newval;
int ret = 0;
if (!pi_state)
return -EINVAL;
/*
* If current does not own the pi_state then the futex is
* inconsistent and user space fiddled with the futex value.
*/
if (pi_state->owner != current)
return -EINVAL;
raw_spin_lock(&pi_state->pi_mutex.wait_lock);
new_owner = rt_mutex_next_owner(&pi_state->pi_mutex);
/*
* It is possible that the next waiter (the one that brought
* this owner to the kernel) timed out and is no longer
* waiting on the lock.
*/
if (!new_owner)
new_owner = this->task;
/*
* We pass it to the next owner. The WAITERS bit is always
* kept enabled while there is PI state around. We cleanup the
* owner died bit, because we are the owner.
*/
newval = FUTEX_WAITERS | task_pid_vnr(new_owner);
if (<API key>(&curval, uaddr, uval, newval))
ret = -EFAULT;
else if (curval != uval)
ret = -EINVAL;
if (ret) {
raw_spin_unlock(&pi_state->pi_mutex.wait_lock);
return ret;
}
raw_spin_lock_irq(&pi_state->owner->pi_lock);
WARN_ON(list_empty(&pi_state->list));
list_del_init(&pi_state->list);
raw_spin_unlock_irq(&pi_state->owner->pi_lock);
raw_spin_lock_irq(&new_owner->pi_lock);
WARN_ON(!list_empty(&pi_state->list));
list_add(&pi_state->list, &new_owner->pi_state_list);
pi_state->owner = new_owner;
raw_spin_unlock_irq(&new_owner->pi_lock);
raw_spin_unlock(&pi_state->pi_mutex.wait_lock);
rt_mutex_unlock(&pi_state->pi_mutex);
return 0;
}
static int unlock_futex_pi(u32 __user *uaddr, u32 uval)
{
u32 uninitialized_var(oldval);
/*
* There is no waiter, so we unlock the futex. The owner died
* bit has not to be preserved here. We are the owner:
*/
if (<API key>(&oldval, uaddr, uval, 0))
return -EFAULT;
if (oldval != uval)
return -EAGAIN;
return 0;
}
/*
* Express the locking dependencies for lockdep:
*/
static inline void
double_lock_hb(struct futex_hash_bucket *hb1, struct futex_hash_bucket *hb2)
{
if (hb1 <= hb2) {
spin_lock(&hb1->lock);
if (hb1 < hb2)
spin_lock_nested(&hb2->lock, <API key>);
} else { /* hb1 > hb2 */
spin_lock(&hb2->lock);
spin_lock_nested(&hb1->lock, <API key>);
}
}
static inline void
double_unlock_hb(struct futex_hash_bucket *hb1, struct futex_hash_bucket *hb2)
{
spin_unlock(&hb1->lock);
if (hb1 != hb2)
spin_unlock(&hb2->lock);
}
/*
* Wake up waiters matching bitset queued on this futex (uaddr).
*/
static int
futex_wake(u32 __user *uaddr, unsigned int flags, int nr_wake, u32 bitset)
{
struct futex_hash_bucket *hb;
struct futex_q *this, *next;
struct plist_head *head;
union futex_key key = FUTEX_KEY_INIT;
int ret;
if (!bitset)
return -EINVAL;
ret = get_futex_key(uaddr, flags & FLAGS_SHARED, &key, VERIFY_READ);
if (unlikely(ret != 0))
goto out;
hb = hash_futex(&key);
spin_lock(&hb->lock);
head = &hb->chain;
<API key>(this, next, head, list) {
if (match_futex (&this->key, &key)) {
if (this->pi_state || this->rt_waiter) {
ret = -EINVAL;
break;
}
/* Check if one of the bits is set in both bitsets */
if (!(this->bitset & bitset))
continue;
wake_futex(this);
if (++ret >= nr_wake)
break;
}
}
spin_unlock(&hb->lock);
put_futex_key(&key);
out:
return ret;
}
/*
* Wake up all waiters hashed on the physical page that is mapped
* to this virtual address:
*/
static int
futex_wake_op(u32 __user *uaddr1, unsigned int flags, u32 __user *uaddr2,
int nr_wake, int nr_wake2, int op)
{
union futex_key key1 = FUTEX_KEY_INIT, key2 = FUTEX_KEY_INIT;
struct futex_hash_bucket *hb1, *hb2;
struct plist_head *head;
struct futex_q *this, *next;
int ret, op_ret;
retry:
ret = get_futex_key(uaddr1, flags & FLAGS_SHARED, &key1, VERIFY_READ);
if (unlikely(ret != 0))
goto out;
ret = get_futex_key(uaddr2, flags & FLAGS_SHARED, &key2, VERIFY_WRITE);
if (unlikely(ret != 0))
goto out_put_key1;
hb1 = hash_futex(&key1);
hb2 = hash_futex(&key2);
retry_private:
double_lock_hb(hb1, hb2);
op_ret = <API key>(op, uaddr2);
if (unlikely(op_ret < 0)) {
double_unlock_hb(hb1, hb2);
#ifndef CONFIG_MMU
/*
* we don't get EFAULT from MMU faults if we don't have an MMU,
* but we might get them from range checking
*/
ret = op_ret;
goto out_put_keys;
#endif
if (unlikely(op_ret != -EFAULT)) {
ret = op_ret;
goto out_put_keys;
}
ret = <API key>(uaddr2);
if (ret)
goto out_put_keys;
if (!(flags & FLAGS_SHARED))
goto retry_private;
put_futex_key(&key2);
put_futex_key(&key1);
goto retry;
}
head = &hb1->chain;
<API key>(this, next, head, list) {
if (match_futex (&this->key, &key1)) {
if (this->pi_state || this->rt_waiter) {
ret = -EINVAL;
goto out_unlock;
}
wake_futex(this);
if (++ret >= nr_wake)
break;
}
}
if (op_ret > 0) {
head = &hb2->chain;
op_ret = 0;
<API key>(this, next, head, list) {
if (match_futex (&this->key, &key2)) {
if (this->pi_state || this->rt_waiter) {
ret = -EINVAL;
goto out_unlock;
}
wake_futex(this);
if (++op_ret >= nr_wake2)
break;
}
}
ret += op_ret;
}
out_unlock:
double_unlock_hb(hb1, hb2);
out_put_keys:
put_futex_key(&key2);
out_put_key1:
put_futex_key(&key1);
out:
return ret;
}
/**
* requeue_futex() - Requeue a futex_q from one hb to another
* @q: the futex_q to requeue
* @hb1: the source hash_bucket
* @hb2: the target hash_bucket
* @key2: the new key for the requeued futex_q
*/
static inline
void requeue_futex(struct futex_q *q, struct futex_hash_bucket *hb1,
struct futex_hash_bucket *hb2, union futex_key *key2)
{
/*
* If key1 and key2 hash to the same bucket, no need to
* requeue.
*/
if (likely(&hb1->chain != &hb2->chain)) {
plist_del(&q->list, &hb1->chain);
plist_add(&q->list, &hb2->chain);
q->lock_ptr = &hb2->lock;
}
get_futex_key_refs(key2);
q->key = *key2;
}
/**
* <API key>() - Wake a task that acquired the lock during requeue
* @q: the futex_q
* @key: the key of the requeue target futex
* @hb: the hash_bucket of the requeue target futex
*
* During futex_requeue, with requeue_pi=1, it is possible to acquire the
* target futex if it is uncontended or via a lock steal. Set the futex_q key
* to the requeue target futex so the waiter can detect the wakeup on the right
* futex, but remove it from the hb and NULL the rt_waiter so it can detect
* atomic lock acquisition. Set the q->lock_ptr to the requeue target hb->lock
* to protect access to the pi_state to fixup the owner later. Must be called
* with both q->lock_ptr and hb->lock held.
*/
static inline
void <API key>(struct futex_q *q, union futex_key *key,
struct futex_hash_bucket *hb)
{
get_futex_key_refs(key);
q->key = *key;
__unqueue_futex(q);
WARN_ON(!q->rt_waiter);
q->rt_waiter = NULL;
q->lock_ptr = &hb->lock;
wake_up_state(q->task, TASK_NORMAL);
}
/**
* <API key>() - Attempt an atomic lock for the top waiter
* @pifutex: the user address of the to futex
* @hb1: the from futex hash bucket, must be locked by the caller
* @hb2: the to futex hash bucket, must be locked by the caller
* @key1: the from futex key
* @key2: the to futex key
* @ps: address to store the pi_state pointer
* @set_waiters: force setting the FUTEX_WAITERS bit (1) or not (0)
*
* Try and get the lock on behalf of the top waiter if we can do it atomically.
* Wake the top waiter if we succeed. If the caller specified set_waiters,
* then direct <API key>() to force setting the FUTEX_WAITERS bit.
* hb1 and hb2 must be held by the caller.
*
* Return:
* 0 - failed to acquire the lock atomically;
* >0 - acquired the lock, return value is vpid of the top_waiter
* <0 - error
*/
static int <API key>(u32 __user *pifutex,
struct futex_hash_bucket *hb1,
struct futex_hash_bucket *hb2,
union futex_key *key1, union futex_key *key2,
struct futex_pi_state **ps, int set_waiters)
{
struct futex_q *top_waiter = NULL;
u32 curval;
int ret, vpid;
if (<API key>(&curval, pifutex))
return -EFAULT;
/*
* Find the top_waiter and determine if there are additional waiters.
* If the caller intends to requeue more than 1 waiter to pifutex,
* force <API key>() to set the FUTEX_WAITERS bit now,
* as we have means to handle the possible fault. If not, don't set
* the bit unecessarily as it will force the subsequent unlock to enter
* the kernel.
*/
top_waiter = futex_top_waiter(hb1, key1);
/* There are no waiters, nothing for us to do. */
if (!top_waiter)
return 0;
/* Ensure we requeue to the expected futex. */
if (!match_futex(top_waiter->requeue_pi_key, key2))
return -EINVAL;
/*
* Try to take the lock for top_waiter. Set the FUTEX_WAITERS bit in
* the contended case or if set_waiters is 1. The pi_state is returned
* in ps in contended cases.
*/
vpid = task_pid_vnr(top_waiter->task);
ret = <API key>(pifutex, hb2, key2, ps, top_waiter->task,
set_waiters);
if (ret == 1) {
<API key>(top_waiter, key2, hb2);
return vpid;
}
return ret;
}
/**
* futex_requeue() - Requeue waiters from uaddr1 to uaddr2
* @uaddr1: source futex user address
* @flags: futex flags (FLAGS_SHARED, etc.)
* @uaddr2: target futex user address
* @nr_wake: number of waiters to wake (must be 1 for requeue_pi)
* @nr_requeue: number of waiters to requeue (0-INT_MAX)
* @cmpval: @uaddr1 expected value (or %NULL)
* @requeue_pi: if we are attempting to requeue from a non-pi futex to a
* pi futex (pi to pi requeue is not supported)
*
* Requeue waiters on uaddr1 to uaddr2. In the requeue_pi case, try to acquire
* uaddr2 atomically on behalf of the top waiter.
*
* Return:
* >=0 - on success, the number of tasks requeued or woken;
* <0 - on error
*/
static int futex_requeue(u32 __user *uaddr1, unsigned int flags,
u32 __user *uaddr2, int nr_wake, int nr_requeue,
u32 *cmpval, int requeue_pi)
{
union futex_key key1 = FUTEX_KEY_INIT, key2 = FUTEX_KEY_INIT;
int drop_count = 0, task_count = 0, ret;
struct futex_pi_state *pi_state = NULL;
struct futex_hash_bucket *hb1, *hb2;
struct plist_head *head1;
struct futex_q *this, *next;
u32 curval2;
if (requeue_pi) {
/*
* Requeue PI only works on two distinct uaddrs. This
* check is only valid for private futexes. See below.
*/
if (uaddr1 == uaddr2)
return -EINVAL;
/*
* requeue_pi requires a pi_state, try to allocate it now
* without any locks in case it fails.
*/
if (<API key>())
return -ENOMEM;
/*
* requeue_pi must wake as many tasks as it can, up to nr_wake
* + nr_requeue, since it acquires the rt_mutex prior to
* returning to userspace, so as to not leave the rt_mutex with
* waiters and no owner. However, second and third wake-ups
* cannot be predicted as they involve race conditions with the
* first wake and a fault while looking up the pi_state. Both
* pthread_cond_signal() and <API key>() should
* use nr_wake=1.
*/
if (nr_wake != 1)
return -EINVAL;
}
retry:
if (pi_state != NULL) {
/*
* We will have to lookup the pi_state again, so free this one
* to keep the accounting correct.
*/
free_pi_state(pi_state);
pi_state = NULL;
}
ret = get_futex_key(uaddr1, flags & FLAGS_SHARED, &key1, VERIFY_READ);
if (unlikely(ret != 0))
goto out;
ret = get_futex_key(uaddr2, flags & FLAGS_SHARED, &key2,
requeue_pi ? VERIFY_WRITE : VERIFY_READ);
if (unlikely(ret != 0))
goto out_put_key1;
/*
* The check above which compares uaddrs is not sufficient for
* shared futexes. We need to compare the keys:
*/
if (requeue_pi && match_futex(&key1, &key2)) {
ret = -EINVAL;
goto out_put_keys;
}
/*
* The check above which compares uaddrs is not sufficient for
* shared futexes. We need to compare the keys:
*/
if (requeue_pi && match_futex(&key1, &key2)) {
ret = -EINVAL;
goto out_put_keys;
}
hb1 = hash_futex(&key1);
hb2 = hash_futex(&key2);
retry_private:
double_lock_hb(hb1, hb2);
if (likely(cmpval != NULL)) {
u32 curval;
ret = <API key>(&curval, uaddr1);
if (unlikely(ret)) {
double_unlock_hb(hb1, hb2);
ret = get_user(curval, uaddr1);
if (ret)
goto out_put_keys;
if (!(flags & FLAGS_SHARED))
goto retry_private;
put_futex_key(&key2);
put_futex_key(&key1);
goto retry;
}
if (curval != *cmpval) {
ret = -EAGAIN;
goto out_unlock;
}
}
if (requeue_pi && (task_count - nr_wake < nr_requeue)) {
/*
* Attempt to acquire uaddr2 and wake the top waiter. If we
* intend to requeue waiters, force setting the FUTEX_WAITERS
* bit. We force this here where we are able to easily handle
* faults rather in the requeue loop below.
*/
ret = <API key>(uaddr2, hb1, hb2, &key1,
&key2, &pi_state, nr_requeue);
/*
* At this point the top_waiter has either taken uaddr2 or is
* waiting on it. If the former, then the pi_state will not
* exist yet, look it up one more time to ensure we have a
* reference to it. If the lock was taken, ret contains the
* vpid of the top waiter task.
*/
if (ret > 0) {
WARN_ON(pi_state);
drop_count++;
task_count++;
/*
* If we acquired the lock, then the user
* space value of uaddr2 should be vpid. It
* cannot be changed by the top waiter as it
* is blocked on hb2 lock if it tries to do
* so. If something fiddled with it behind our
* back the pi state lookup might unearth
* it. So we rather use the known value than
* rereading and handing potential crap to
* lookup_pi_state.
*/
ret = lookup_pi_state(ret, hb2, &key2, &pi_state);
}
switch (ret) {
case 0:
break;
case -EFAULT:
double_unlock_hb(hb1, hb2);
put_futex_key(&key2);
put_futex_key(&key1);
ret = <API key>(uaddr2);
if (!ret)
goto retry;
goto out;
case -EAGAIN:
/* The owner was exiting, try again. */
double_unlock_hb(hb1, hb2);
put_futex_key(&key2);
put_futex_key(&key1);
cond_resched();
goto retry;
default:
goto out_unlock;
}
}
head1 = &hb1->chain;
<API key>(this, next, head1, list) {
if (task_count - nr_wake >= nr_requeue)
break;
if (!match_futex(&this->key, &key1))
continue;
/*
* <API key> and <API key> should always
* be paired with each other and no other futex ops.
*
* We should never be requeueing a futex_q with a pi_state,
* which is awaiting a futex_unlock_pi().
*/
if ((requeue_pi && !this->rt_waiter) ||
(!requeue_pi && this->rt_waiter) ||
this->pi_state) {
ret = -EINVAL;
break;
}
/*
* Wake nr_wake waiters. For requeue_pi, if we acquired the
* lock, we already woke the top_waiter. If not, it will be
* woken by futex_unlock_pi().
*/
if (++task_count <= nr_wake && !requeue_pi) {
wake_futex(this);
continue;
}
/* Ensure we requeue to the expected futex for requeue_pi. */
if (requeue_pi && !match_futex(this->requeue_pi_key, &key2)) {
ret = -EINVAL;
break;
}
/*
* Requeue nr_requeue waiters and possibly one more in the case
* of requeue_pi if we couldn't acquire the lock atomically.
*/
if (requeue_pi) {
/* Prepare the waiter to take the rt_mutex. */
atomic_inc(&pi_state->refcount);
this->pi_state = pi_state;
ret = <API key>(&pi_state->pi_mutex,
this->rt_waiter,
this->task, 1);
if (ret == 1) {
/* We got the lock. */
<API key>(this, &key2, hb2);
drop_count++;
continue;
} else if (ret) {
/* -EDEADLK */
this->pi_state = NULL;
free_pi_state(pi_state);
goto out_unlock;
}
}
requeue_futex(this, hb1, hb2, &key2);
drop_count++;
}
out_unlock:
double_unlock_hb(hb1, hb2);
/*
* drop_futex_key_refs() must be called outside the spinlocks. During
* the requeue we moved futex_q's from the hash bucket at key1 to the
* one at key2 and updated their key pointer. We no longer need to
* hold the references to key1.
*/
while (--drop_count >= 0)
drop_futex_key_refs(&key1);
out_put_keys:
put_futex_key(&key2);
out_put_key1:
put_futex_key(&key1);
out:
if (pi_state != NULL)
free_pi_state(pi_state);
return ret ? ret : task_count;
}
/* The key must be already stored in q->key. */
static inline struct futex_hash_bucket *queue_lock(struct futex_q *q)
__acquires(&hb->lock)
{
struct futex_hash_bucket *hb;
hb = hash_futex(&q->key);
q->lock_ptr = &hb->lock;
spin_lock(&hb->lock);
return hb;
}
static inline void
queue_unlock(struct futex_q *q, struct futex_hash_bucket *hb)
__releases(&hb->lock)
{
spin_unlock(&hb->lock);
}
/**
* queue_me() - Enqueue the futex_q on the futex_hash_bucket
* @q: The futex_q to enqueue
* @hb: The destination hash bucket
*
* The hb->lock must be held by the caller, and is released here. A call to
* queue_me() is typically paired with exactly one call to unqueue_me(). The
* exceptions involve the PI related operations, which may use unqueue_me_pi()
* or nothing if the unqueue is done as part of the wake process and the unqueue
* state is implicit in the state of woken task (see <API key>() for
* an example).
*/
static inline void queue_me(struct futex_q *q, struct futex_hash_bucket *hb)
__releases(&hb->lock)
{
int prio;
/*
* The priority used to register this element is
* - either the real thread-priority for the real-time threads
* (i.e. threads with a priority lower than MAX_RT_PRIO)
* - or MAX_RT_PRIO for non-RT threads.
* Thus, all RT-threads are woken first in priority order, and
* the others are woken last, in FIFO order.
*/
prio = min(current->normal_prio, MAX_RT_PRIO);
plist_node_init(&q->list, prio);
plist_add(&q->list, &hb->chain);
q->task = current;
spin_unlock(&hb->lock);
}
/**
* unqueue_me() - Remove the futex_q from its futex_hash_bucket
* @q: The futex_q to unqueue
*
* The q->lock_ptr must not be held by the caller. A call to unqueue_me() must
* be paired with exactly one earlier call to queue_me().
*
* Return:
* 1 - if the futex_q was still queued (and we removed unqueued it);
* 0 - if the futex_q was already removed by the waking thread
*/
static int unqueue_me(struct futex_q *q)
{
spinlock_t *lock_ptr;
int ret = 0;
/* In the common case we don't take the spinlock, which is nice. */
retry:
lock_ptr = q->lock_ptr;
barrier();
if (lock_ptr != NULL) {
spin_lock(lock_ptr);
/*
* q->lock_ptr can change between reading it and
* spin_lock(), causing us to take the wrong lock. This
* corrects the race condition.
*
* Reasoning goes like this: if we have the wrong lock,
* q->lock_ptr must have changed (maybe several times)
* between reading it and the spin_lock(). It can
* change again after the spin_lock() but only if it was
* already changed before the spin_lock(). It cannot,
* however, change back to the original value. Therefore
* we can detect whether we acquired the correct lock.
*/
if (unlikely(lock_ptr != q->lock_ptr)) {
spin_unlock(lock_ptr);
goto retry;
}
__unqueue_futex(q);
BUG_ON(q->pi_state);
spin_unlock(lock_ptr);
ret = 1;
}
drop_futex_key_refs(&q->key);
return ret;
}
/*
* PI futexes can not be requeued and must remove themself from the
* hash bucket. The hash bucket lock (i.e. lock_ptr) is held on entry
* and dropped here.
*/
static void unqueue_me_pi(struct futex_q *q)
__releases(q->lock_ptr)
{
__unqueue_futex(q);
BUG_ON(!q->pi_state);
free_pi_state(q->pi_state);
q->pi_state = NULL;
spin_unlock(q->lock_ptr);
}
/*
* Fixup the pi_state owner with the new owner.
*
* Must be called with hash bucket lock held and mm->sem held for non
* private futexes.
*/
static int <API key>(u32 __user *uaddr, struct futex_q *q,
struct task_struct *newowner)
{
u32 newtid = task_pid_vnr(newowner) | FUTEX_WAITERS;
struct futex_pi_state *pi_state = q->pi_state;
struct task_struct *oldowner = pi_state->owner;
u32 uval, uninitialized_var(curval), newval;
int ret;
/* Owner died? */
if (!pi_state->owner)
newtid |= FUTEX_OWNER_DIED;
/*
* We are here either because we stole the rtmutex from the
* previous highest priority waiter or we are the highest priority
* waiter but failed to get the rtmutex the first time.
* We have to replace the newowner TID in the user space variable.
* This must be atomic as we have to preserve the owner died bit here.
*
* Note: We write the user space value _before_ changing the pi_state
* because we can fault here. Imagine swapped out pages or a fork
* that marked all the anonymous memory readonly for cow.
*
* Modifying pi_state _before_ the user space value would
* leave the pi_state in an inconsistent state when we fault
* here, because we need to drop the hash bucket lock to
* handle the fault. This might be observed in the PID check
* in lookup_pi_state.
*/
retry:
if (<API key>(&uval, uaddr))
goto handle_fault;
while (1) {
newval = (uval & FUTEX_OWNER_DIED) | newtid;
if (<API key>(&curval, uaddr, uval, newval))
goto handle_fault;
if (curval == uval)
break;
uval = curval;
}
/*
* We fixed up user space. Now we need to fix the pi_state
* itself.
*/
if (pi_state->owner != NULL) {
raw_spin_lock_irq(&pi_state->owner->pi_lock);
WARN_ON(list_empty(&pi_state->list));
list_del_init(&pi_state->list);
raw_spin_unlock_irq(&pi_state->owner->pi_lock);
}
pi_state->owner = newowner;
raw_spin_lock_irq(&newowner->pi_lock);
WARN_ON(!list_empty(&pi_state->list));
list_add(&pi_state->list, &newowner->pi_state_list);
raw_spin_unlock_irq(&newowner->pi_lock);
return 0;
/*
* To handle the page fault we need to drop the hash bucket
* lock here. That gives the other task (either the highest priority
* waiter itself or the task which stole the rtmutex) the
* chance to try the fixup of the pi_state. So once we are
* back from handling the fault we need to check the pi_state
* after reacquiring the hash bucket lock and before trying to
* do another fixup. When the fixup has been done already we
* simply return.
*/
handle_fault:
spin_unlock(q->lock_ptr);
ret = <API key>(uaddr);
spin_lock(q->lock_ptr);
/*
* Check if someone else fixed it for us:
*/
if (pi_state->owner != oldowner)
return 0;
if (ret)
return ret;
goto retry;
}
static long futex_wait_restart(struct restart_block *restart);
/**
* fixup_owner() - Post lock pi_state and corner case management
* @uaddr: user address of the futex
* @q: futex_q (contains pi_state and access to the rt_mutex)
* @locked: if the attempt to take the rt_mutex succeeded (1) or not (0)
*
* After attempting to lock an rt_mutex, this function is called to cleanup
* the pi_state owner as well as handle race conditions that may allow us to
* acquire the lock. Must be called with the hb lock held.
*
* Return:
* 1 - success, lock taken;
* 0 - success, lock not taken;
* <0 - on error (-EFAULT)
*/
static int fixup_owner(u32 __user *uaddr, struct futex_q *q, int locked)
{
struct task_struct *owner;
int ret = 0;
if (locked) {
/*
* Got the lock. We might not be the anticipated owner if we
* did a lock-steal - fix up the PI-state in that case:
*/
if (q->pi_state->owner != current)
ret = <API key>(uaddr, q, current);
goto out;
}
/*
* Catch the rare case, where the lock was released when we were on the
* way back before we locked the hash bucket.
*/
if (q->pi_state->owner == current) {
/*
* Try to get the rt_mutex now. This might fail as some other
* task acquired the rt_mutex after we removed ourself from the
* rt_mutex waiters list.
*/
if (rt_mutex_trylock(&q->pi_state->pi_mutex)) {
locked = 1;
goto out;
}
/*
* pi_state is incorrect, some other task did a lock steal and
* we returned due to timeout or signal without taking the
* rt_mutex. Too late.
*/
raw_spin_lock(&q->pi_state->pi_mutex.wait_lock);
owner = rt_mutex_owner(&q->pi_state->pi_mutex);
if (!owner)
owner = rt_mutex_next_owner(&q->pi_state->pi_mutex);
raw_spin_unlock(&q->pi_state->pi_mutex.wait_lock);
ret = <API key>(uaddr, q, owner);
goto out;
}
/*
* Paranoia check. If we did not take the lock, then we should not be
* the owner of the rt_mutex.
*/
if (rt_mutex_owner(&q->pi_state->pi_mutex) == current)
printk(KERN_ERR "fixup_owner: ret = %d pi-mutex: %p "
"pi-state %p\n", ret,
q->pi_state->pi_mutex.owner,
q->pi_state->owner);
out:
return ret ? ret : locked;
}
/**
* futex_wait_queue_me() - queue_me() and wait for wakeup, timeout, or signal
* @hb: the futex hash bucket, must be locked by the caller
* @q: the futex_q to queue up on
* @timeout: the prepared hrtimer_sleeper, or null for no timeout
*/
static void futex_wait_queue_me(struct futex_hash_bucket *hb, struct futex_q *q,
struct hrtimer_sleeper *timeout)
{
/*
* The task state is guaranteed to be set before another task can
* wake it. set_current_state() is implemented using set_mb() and
* queue_me() calls spin_unlock() upon completion, both serializing
* access to the hash list and forcing another memory barrier.
*/
set_current_state(TASK_INTERRUPTIBLE);
queue_me(q, hb);
/* Arm the timer */
if (timeout) {
<API key>(&timeout->timer, HRTIMER_MODE_ABS);
if (!hrtimer_active(&timeout->timer))
timeout->task = NULL;
}
/*
* If we have been removed from the hash list, then another task
* has tried to wake us, and we can skip the call to schedule().
*/
if (likely(!plist_node_empty(&q->list))) {
/*
* If the timer has already expired, current will already be
* flagged for rescheduling. Only call schedule if there
* is no timeout, or if it has yet to expire.
*/
if (!timeout || timeout->task)
freezable_schedule();
}
__set_current_state(TASK_RUNNING);
}
/**
* futex_wait_setup() - Prepare to wait on a futex
* @uaddr: the futex userspace address
* @val: the expected value
* @flags: futex flags (FLAGS_SHARED, etc.)
* @q: the associated futex_q
* @hb: storage for hash_bucket pointer to be returned to caller
*
* Setup the futex_q and locate the hash_bucket. Get the futex value and
* compare it with the expected value. Handle atomic faults internally.
* Return with the hb lock held and a q.key reference on success, and unlocked
* with no q.key reference on failure.
*
* Return:
* 0 - uaddr contains val and hb has been locked;
* <1 - -EFAULT or -EWOULDBLOCK (uaddr does not contain val) and hb is unlocked
*/
static int futex_wait_setup(u32 __user *uaddr, u32 val, unsigned int flags,
struct futex_q *q, struct futex_hash_bucket **hb)
{
u32 uval;
int ret;
/*
* Access the page AFTER the hash-bucket is locked.
* Order is important:
*
* Userspace waiter: val = var; if (cond(val)) futex_wait(&var, val);
* Userspace waker: if (cond(var)) { var = new; futex_wake(&var); }
*
* The basic logical guarantee of a futex is that it blocks ONLY
* if cond(var) is known to be true at the time of blocking, for
* any cond. If we locked the hash-bucket after testing *uaddr, that
* would open a race condition where we could block indefinitely with
* cond(var) false, which would violate the guarantee.
*
* On the other hand, we insert q and release the hash-bucket only
* after testing *uaddr. This guarantees that futex_wait() will NOT
* absorb a wakeup if *uaddr does not match the desired values
* while the syscall executes.
*/
retry:
ret = get_futex_key(uaddr, flags & FLAGS_SHARED, &q->key, VERIFY_READ);
if (unlikely(ret != 0))
return ret;
retry_private:
*hb = queue_lock(q);
ret = <API key>(&uval, uaddr);
if (ret) {
queue_unlock(q, *hb);
ret = get_user(uval, uaddr);
if (ret)
goto out;
if (!(flags & FLAGS_SHARED))
goto retry_private;
put_futex_key(&q->key);
goto retry;
}
if (uval != val) {
queue_unlock(q, *hb);
ret = -EWOULDBLOCK;
}
out:
if (ret)
put_futex_key(&q->key);
return ret;
}
static int futex_wait(u32 __user *uaddr, unsigned int flags, u32 val,
ktime_t *abs_time, u32 bitset)
{
struct hrtimer_sleeper timeout, *to = NULL;
struct restart_block *restart;
struct futex_hash_bucket *hb;
struct futex_q q = futex_q_init;
int ret;
if (!bitset)
return -EINVAL;
q.bitset = bitset;
if (abs_time) {
to = &timeout;
<API key>(&to->timer, (flags & FLAGS_CLOCKRT) ?
CLOCK_REALTIME : CLOCK_MONOTONIC,
HRTIMER_MODE_ABS);
<API key>(to, current);
<API key>(&to->timer, *abs_time,
current->timer_slack_ns);
}
retry:
/*
* Prepare to wait on uaddr. On success, holds hb lock and increments
* q.key refs.
*/
ret = futex_wait_setup(uaddr, val, flags, &q, &hb);
if (ret)
goto out;
/* queue_me and wait for wakeup, timeout, or a signal. */
futex_wait_queue_me(hb, &q, to);
/* If we were woken (and unqueued), we succeeded, whatever. */
ret = 0;
/* unqueue_me() drops q.key ref */
if (!unqueue_me(&q))
goto out;
ret = -ETIMEDOUT;
if (to && !to->task)
goto out;
/*
* We expect signal_pending(current), but we might be the
* victim of a spurious wakeup as well.
*/
if (!signal_pending(current))
goto retry;
ret = -ERESTARTSYS;
if (!abs_time)
goto out;
restart = ¤t_thread_info()->restart_block;
restart->fn = futex_wait_restart;
restart->futex.uaddr = uaddr;
restart->futex.val = val;
restart->futex.time = abs_time->tv64;
restart->futex.bitset = bitset;
restart->futex.flags = flags | FLAGS_HAS_TIMEOUT;
ret = -<API key>;
out:
if (to) {
hrtimer_cancel(&to->timer);
<API key>(&to->timer);
}
return ret;
}
static long futex_wait_restart(struct restart_block *restart)
{
u32 __user *uaddr = restart->futex.uaddr;
ktime_t t, *tp = NULL;
if (restart->futex.flags & FLAGS_HAS_TIMEOUT) {
t.tv64 = restart->futex.time;
tp = &t;
}
restart->fn = <API key>;
return (long)futex_wait(uaddr, restart->futex.flags,
restart->futex.val, tp, restart->futex.bitset);
}
/*
* Userspace tried a 0 -> TID atomic transition of the futex value
* and failed. The kernel side here does the whole locking operation:
* if there are waiters then it will block, it does PI, etc. (Due to
* races the kernel might see a 0 value of the futex too.)
*/
static int futex_lock_pi(u32 __user *uaddr, unsigned int flags, int detect,
ktime_t *time, int trylock)
{
struct hrtimer_sleeper timeout, *to = NULL;
struct futex_hash_bucket *hb;
struct futex_q q = futex_q_init;
int res, ret;
if (<API key>())
return -ENOMEM;
if (time) {
to = &timeout;
<API key>(&to->timer, CLOCK_REALTIME,
HRTIMER_MODE_ABS);
<API key>(to, current);
hrtimer_set_expires(&to->timer, *time);
}
retry:
ret = get_futex_key(uaddr, flags & FLAGS_SHARED, &q.key, VERIFY_WRITE);
if (unlikely(ret != 0))
goto out;
retry_private:
hb = queue_lock(&q);
ret = <API key>(uaddr, hb, &q.key, &q.pi_state, current, 0);
if (unlikely(ret)) {
switch (ret) {
case 1:
/* We got the lock. */
ret = 0;
goto out_unlock_put_key;
case -EFAULT:
goto uaddr_faulted;
case -EAGAIN:
/*
* Task is exiting and we just wait for the
* exit to complete.
*/
queue_unlock(&q, hb);
put_futex_key(&q.key);
cond_resched();
goto retry;
default:
goto out_unlock_put_key;
}
}
/*
* Only actually queue now that the atomic ops are done:
*/
queue_me(&q, hb);
WARN_ON(!q.pi_state);
/*
* Block on the PI mutex:
*/
if (!trylock)
ret = rt_mutex_timed_lock(&q.pi_state->pi_mutex, to, 1);
else {
ret = rt_mutex_trylock(&q.pi_state->pi_mutex);
/* Fixup the trylock return value: */
ret = ret ? 0 : -EWOULDBLOCK;
}
spin_lock(q.lock_ptr);
/*
* Fixup the pi_state owner and possibly acquire the lock if we
* haven't already.
*/
res = fixup_owner(uaddr, &q, !ret);
/*
* If fixup_owner() returned an error, proprogate that. If it acquired
* the lock, clear our -ETIMEDOUT or -EINTR.
*/
if (res)
ret = (res < 0) ? res : 0;
/*
* If fixup_owner() faulted and was unable to handle the fault, unlock
* it and return the fault to userspace.
*/
if (ret && (rt_mutex_owner(&q.pi_state->pi_mutex) == current))
rt_mutex_unlock(&q.pi_state->pi_mutex);
/* Unqueue and drop the lock */
unqueue_me_pi(&q);
goto out_put_key;
out_unlock_put_key:
queue_unlock(&q, hb);
out_put_key:
put_futex_key(&q.key);
out:
if (to)
<API key>(&to->timer);
return ret != -EINTR ? ret : -ERESTARTNOINTR;
uaddr_faulted:
queue_unlock(&q, hb);
ret = <API key>(uaddr);
if (ret)
goto out_put_key;
if (!(flags & FLAGS_SHARED))
goto retry_private;
put_futex_key(&q.key);
goto retry;
}
/*
* Userspace attempted a TID -> 0 atomic transition, and failed.
* This is the in-kernel slowpath: we look up the PI state (if any),
* and do the rt-mutex unlock.
*/
static int futex_unlock_pi(u32 __user *uaddr, unsigned int flags)
{
struct futex_hash_bucket *hb;
struct futex_q *this, *next;
struct plist_head *head;
union futex_key key = FUTEX_KEY_INIT;
u32 uval, vpid = task_pid_vnr(current);
int ret;
retry:
if (get_user(uval, uaddr))
return -EFAULT;
/*
* We release only a lock we actually own:
*/
if ((uval & FUTEX_TID_MASK) != vpid)
return -EPERM;
ret = get_futex_key(uaddr, flags & FLAGS_SHARED, &key, VERIFY_WRITE);
if (unlikely(ret != 0))
goto out;
hb = hash_futex(&key);
spin_lock(&hb->lock);
/*
* To avoid races, try to do the TID -> 0 atomic transition
* again. If it succeeds then we can return without waking
* anyone else up. We only try this if neither the waiters nor
* the owner died bit are set.
*/
if (!(uval & ~FUTEX_TID_MASK) &&
<API key>(&uval, uaddr, vpid, 0))
goto pi_faulted;
/*
* Rare case: we managed to release the lock atomically,
* no need to wake anyone else up:
*/
if (unlikely(uval == vpid))
goto out_unlock;
/*
* Ok, other tasks may need to be woken up - check waiters
* and do the wakeup if necessary:
*/
head = &hb->chain;
<API key>(this, next, head, list) {
if (!match_futex (&this->key, &key))
continue;
ret = wake_futex_pi(uaddr, uval, this);
/*
* The atomic access to the futex value
* generated a pagefault, so retry the
* user-access and the wakeup:
*/
if (ret == -EFAULT)
goto pi_faulted;
goto out_unlock;
}
/*
* No waiters - kernel unlocks the futex:
*/
ret = unlock_futex_pi(uaddr, uval);
if (ret == -EFAULT)
goto pi_faulted;
out_unlock:
spin_unlock(&hb->lock);
put_futex_key(&key);
out:
return ret;
pi_faulted:
spin_unlock(&hb->lock);
put_futex_key(&key);
ret = <API key>(uaddr);
if (!ret)
goto retry;
return ret;
}
/**
* <API key>() - Detect early wakeup on the initial futex
* @hb: the hash_bucket futex_q was original enqueued on
* @q: the futex_q woken while waiting to be requeued
* @key2: the futex_key of the requeue target futex
* @timeout: the timeout associated with the wait (NULL if none)
*
* Detect if the task was woken on the initial futex as opposed to the requeue
* target futex. If so, determine if it was a timeout or a signal that caused
* the wakeup and return the appropriate error code to the caller. Must be
* called with the hb lock held.
*
* Return:
* 0 = no early wakeup detected;
* <0 = -ETIMEDOUT or -ERESTARTNOINTR
*/
static inline
int <API key>(struct futex_hash_bucket *hb,
struct futex_q *q, union futex_key *key2,
struct hrtimer_sleeper *timeout)
{
int ret = 0;
/*
* With the hb lock held, we avoid races while we process the wakeup.
* We only need to hold hb (and not hb2) to ensure atomicity as the
* wakeup code can't change q.key from uaddr to uaddr2 if we hold hb.
* It can't be requeued from uaddr2 to something else since we don't
* support a PI aware source futex for requeue.
*/
if (!match_futex(&q->key, key2)) {
WARN_ON(q->lock_ptr && (&hb->lock != q->lock_ptr));
/*
* We were woken prior to requeue by a timeout or a signal.
* Unqueue the futex_q and determine which it was.
*/
plist_del(&q->list, &hb->chain);
/* Handle spurious wakeups gracefully */
ret = -EWOULDBLOCK;
if (timeout && !timeout->task)
ret = -ETIMEDOUT;
else if (signal_pending(current))
ret = -ERESTARTNOINTR;
}
return ret;
}
/**
* <API key>() - Wait on uaddr and take uaddr2
* @uaddr: the futex we initially wait on (non-pi)
* @flags: futex flags (FLAGS_SHARED, FLAGS_CLOCKRT, etc.), they must be
* the same type, no requeueing from private to shared, etc.
* @val: the expected value of uaddr
* @abs_time: absolute timeout
* @bitset: 32 bit wakeup bitset set by userspace, defaults to all
* @uaddr2: the pi futex we will take prior to returning to user-space
*
* The caller will wait on uaddr and will be requeued by futex_requeue() to
* uaddr2 which must be PI aware and unique from uaddr. Normal wakeup will wake
* on uaddr2 and complete the acquisition of the rt_mutex prior to returning to
* userspace. This ensures the rt_mutex maintains an owner when it has waiters;
* without one, the pi logic would not know which task to boost/deboost, if
* there was a need to.
*
* We call schedule in futex_wait_queue_me() when we enqueue and return there
* via the following--
* 1) wakeup on uaddr2 after an atomic lock acquisition by futex_requeue()
* 2) wakeup on uaddr2 after a requeue
* 3) signal
* 4) timeout
*
* If 3, cleanup and return -ERESTARTNOINTR.
*
* If 2, we may then block on trying to take the rt_mutex and return via:
* 5) successful lock
* 6) signal
* 7) timeout
* 8) other lock acquisition failure
*
* If 6, return -EWOULDBLOCK (restarting the syscall would do the same).
*
* If 4 or 7, we cleanup and return with -ETIMEDOUT.
*
* Return:
* 0 - On success;
* <0 - On error
*/
static int <API key>(u32 __user *uaddr, unsigned int flags,
u32 val, ktime_t *abs_time, u32 bitset,
u32 __user *uaddr2)
{
struct hrtimer_sleeper timeout, *to = NULL;
struct rt_mutex_waiter rt_waiter;
struct rt_mutex *pi_mutex = NULL;
struct futex_hash_bucket *hb;
union futex_key key2 = FUTEX_KEY_INIT;
struct futex_q q = futex_q_init;
int res, ret;
if (uaddr == uaddr2)
return -EINVAL;
if (!bitset)
return -EINVAL;
if (abs_time) {
to = &timeout;
<API key>(&to->timer, (flags & FLAGS_CLOCKRT) ?
CLOCK_REALTIME : CLOCK_MONOTONIC,
HRTIMER_MODE_ABS);
<API key>(to, current);
<API key>(&to->timer, *abs_time,
current->timer_slack_ns);
}
/*
* The waiter is allocated on our stack, manipulated by the requeue
* code while we sleep on uaddr.
*/
<API key>(&rt_waiter);
rt_waiter.task = NULL;
ret = get_futex_key(uaddr2, flags & FLAGS_SHARED, &key2, VERIFY_WRITE);
if (unlikely(ret != 0))
goto out;
q.bitset = bitset;
q.rt_waiter = &rt_waiter;
q.requeue_pi_key = &key2;
/*
* Prepare to wait on uaddr. On success, increments q.key (key1) ref
* count.
*/
ret = futex_wait_setup(uaddr, val, flags, &q, &hb);
if (ret)
goto out_key2;
/*
* The check above which compares uaddrs is not sufficient for
* shared futexes. We need to compare the keys:
*/
if (match_futex(&q.key, &key2)) {
ret = -EINVAL;
goto out_put_keys;
}
/*
* The check above which compares uaddrs is not sufficient for
* shared futexes. We need to compare the keys:
*/
if (match_futex(&q.key, &key2)) {
ret = -EINVAL;
goto out_put_keys;
}
/* Queue the futex_q, drop the hb lock, wait for wakeup. */
futex_wait_queue_me(hb, &q, to);
spin_lock(&hb->lock);
ret = <API key>(hb, &q, &key2, to);
spin_unlock(&hb->lock);
if (ret)
goto out_put_keys;
/*
* In order for us to be here, we know our q.key == key2, and since
* we took the hb->lock above, we also know that futex_requeue() has
* completed and we no longer have to concern ourselves with a wakeup
* race with the atomic proxy lock acquisition by the requeue code. The
* futex_requeue dropped our key1 reference and incremented our key2
* reference count.
*/
/* Check if the requeue code acquired the second futex for us. */
if (!q.rt_waiter) {
/*
* Got the lock. We might not be the anticipated owner if we
* did a lock-steal - fix up the PI-state in that case.
*/
if (q.pi_state && (q.pi_state->owner != current)) {
spin_lock(q.lock_ptr);
ret = <API key>(uaddr2, &q, current);
spin_unlock(q.lock_ptr);
}
} else {
/*
* We have been woken up by futex_unlock_pi(), a timeout, or a
* signal. futex_unlock_pi() will not destroy the lock_ptr nor
* the pi_state.
*/
WARN_ON(!q.pi_state);
pi_mutex = &q.pi_state->pi_mutex;
ret = <API key>(pi_mutex, to, &rt_waiter, 1);
<API key>(&rt_waiter);
spin_lock(q.lock_ptr);
/*
* Fixup the pi_state owner and possibly acquire the lock if we
* haven't already.
*/
res = fixup_owner(uaddr2, &q, !ret);
/*
* If fixup_owner() returned an error, proprogate that. If it
* acquired the lock, clear -ETIMEDOUT or -EINTR.
*/
if (res)
ret = (res < 0) ? res : 0;
/* Unqueue and drop the lock. */
unqueue_me_pi(&q);
}
/*
* If <API key>() faulted and was unable to handle the
* fault, unlock the rt_mutex and return the fault to userspace.
*/
if (ret == -EFAULT) {
if (pi_mutex && rt_mutex_owner(pi_mutex) == current)
rt_mutex_unlock(pi_mutex);
} else if (ret == -EINTR) {
/*
* We've already been requeued, but cannot restart by calling
* futex_lock_pi() directly. We could restart this syscall, but
* it would detect that the user space "val" changed and return
* -EWOULDBLOCK. Save the overhead of the restart and return
* -EWOULDBLOCK directly.
*/
ret = -EWOULDBLOCK;
}
out_put_keys:
put_futex_key(&q.key);
out_key2:
put_futex_key(&key2);
out:
if (to) {
hrtimer_cancel(&to->timer);
<API key>(&to->timer);
}
return ret;
}
/*
* Support for robust futexes: the kernel cleans up held futexes at
* thread exit time.
*
* Implementation: user-space maintains a per-thread list of locks it
* is holding. Upon do_exit(), the kernel carefully walks this list,
* and marks all locks that are owned by this thread with the
* FUTEX_OWNER_DIED bit, and wakes up a waiter (if any). The list is
* always manipulated with the lock held, so the list is private and
* per-thread. Userspace also maintains a per-thread 'list_op_pending'
* field, to allow the kernel to clean up if the thread dies after
* acquiring the lock, but just before it could have added itself to
* the list. There can only be one such pending lock.
*/
/**
* sys_set_robust_list() - Set the robust-futex list head of a task
* @head: pointer to the list-head
* @len: length of the list-head, as userspace expects
*/
SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head,
size_t, len)
{
if (!<API key>)
return -ENOSYS;
/*
* The kernel knows only one size for now:
*/
if (unlikely(len != sizeof(*head)))
return -EINVAL;
current->robust_list = head;
return 0;
}
/**
* sys_get_robust_list() - Get the robust-futex list head of a task
* @pid: pid of the process [zero for current task]
* @head_ptr: pointer to a list-head pointer, the kernel fills it in
* @len_ptr: pointer to a length field, the kernel fills in the header size
*/
SYSCALL_DEFINE3(get_robust_list, int, pid,
struct robust_list_head __user * __user *, head_ptr,
size_t __user *, len_ptr)
{
struct robust_list_head __user *head;
unsigned long ret;
struct task_struct *p;
if (!<API key>)
return -ENOSYS;
rcu_read_lock();
ret = -ESRCH;
if (!pid)
p = current;
else {
p = find_task_by_vpid(pid);
if (!p)
goto err_unlock;
}
ret = -EPERM;
if (!ptrace_may_access(p, PTRACE_MODE_READ))
goto err_unlock;
head = p->robust_list;
rcu_read_unlock();
if (put_user(sizeof(*head), len_ptr))
return -EFAULT;
return put_user(head, head_ptr);
err_unlock:
rcu_read_unlock();
return ret;
}
/*
* Process a futex-list entry, check whether it's owned by the
* dying task, and do notification if so:
*/
int handle_futex_death(u32 __user *uaddr, struct task_struct *curr, int pi)
{
u32 uval, uninitialized_var(nval), mval;
retry:
if (get_user(uval, uaddr))
return -1;
if ((uval & FUTEX_TID_MASK) == task_pid_vnr(curr)) {
/*
* Ok, this dying thread is truly holding a futex
* of interest. Set the OWNER_DIED bit atomically
* via cmpxchg, and if the value had FUTEX_WAITERS
* set, wake up a waiter (if any). (We have to do a
* futex_wake() even if OWNER_DIED is already set -
* to handle the rare but possible case of recursive
* thread-death.) The rest of the cleanup is done in
* userspace.
*/
mval = (uval & FUTEX_WAITERS) | FUTEX_OWNER_DIED;
/*
* We are not holding a lock here, but we want to have
* the pagefault_disable/enable() protection because
* we want to handle the fault gracefully. If the
* access fails we try to fault in the futex with R/W
* verification via get_user_pages. get_user() above
* does not guarantee R/W access. If that fails we
* give up and leave the futex locked.
*/
if (<API key>(&nval, uaddr, uval, mval)) {
if (<API key>(uaddr))
return -1;
goto retry;
}
if (nval != uval)
goto retry;
/*
* Wake robust non-PI futexes here. The wakeup of
* PI futexes happens in exit_pi_state():
*/
if (!pi && (uval & FUTEX_WAITERS))
futex_wake(uaddr, 1, 1, <API key>);
}
return 0;
}
/*
* Fetch a robust-list pointer. Bit 0 signals PI futexes:
*/
static inline int fetch_robust_entry(struct robust_list __user **entry,
struct robust_list __user * __user *head,
unsigned int *pi)
{
unsigned long uentry;
if (get_user(uentry, (unsigned long __user *)head))
return -EFAULT;
*entry = (void __user *)(uentry & ~1UL);
*pi = uentry & 1;
return 0;
}
/*
* Walk curr->robust_list (very carefully, it's a userspace list!)
* and mark any locks found there dead, and notify any waiters.
*
* We silently return on any sign of list-walking problem.
*/
void exit_robust_list(struct task_struct *curr)
{
struct robust_list_head __user *head = curr->robust_list;
struct robust_list __user *entry, *next_entry, *pending;
unsigned int limit = ROBUST_LIST_LIMIT, pi, pip;
unsigned int uninitialized_var(next_pi);
unsigned long futex_offset;
int rc;
if (!<API key>)
return;
/*
* Fetch the list head (which was registered earlier, via
* sys_set_robust_list()):
*/
if (fetch_robust_entry(&entry, &head->list.next, &pi))
return;
/*
* Fetch the relative futex offset:
*/
if (get_user(futex_offset, &head->futex_offset))
return;
/*
* Fetch any possibly pending lock-add first, and handle it
* if it exists:
*/
if (fetch_robust_entry(&pending, &head->list_op_pending, &pip))
return;
next_entry = NULL; /* avoid warning with gcc */
while (entry != &head->list) {
/*
* Fetch the next entry in the list before calling
* handle_futex_death:
*/
rc = fetch_robust_entry(&next_entry, &entry->next, &next_pi);
/*
* A pending lock might already be on the list, so
* don't process it twice:
*/
if (entry != pending)
if (handle_futex_death((void __user *)entry + futex_offset,
curr, pi))
return;
if (rc)
return;
entry = next_entry;
pi = next_pi;
/*
* Avoid excessively long or circular lists:
*/
if (!--limit)
break;
cond_resched();
}
if (pending)
handle_futex_death((void __user *)pending + futex_offset,
curr, pip);
}
long do_futex(u32 __user *uaddr, int op, u32 val, ktime_t *timeout,
u32 __user *uaddr2, u32 val2, u32 val3)
{
int cmd = op & FUTEX_CMD_MASK;
unsigned int flags = 0;
if (!(op & FUTEX_PRIVATE_FLAG))
flags |= FLAGS_SHARED;
if (op & <API key>) {
flags |= FLAGS_CLOCKRT;
if (cmd != FUTEX_WAIT_BITSET && cmd != <API key>)
return -ENOSYS;
}
switch (cmd) {
case FUTEX_LOCK_PI:
case FUTEX_UNLOCK_PI:
case FUTEX_TRYLOCK_PI:
case <API key>:
case <API key>:
if (!<API key>)
return -ENOSYS;
}
switch (cmd) {
case FUTEX_WAIT:
val3 = <API key>;
case FUTEX_WAIT_BITSET:
return futex_wait(uaddr, flags, val, timeout, val3);
case FUTEX_WAKE:
val3 = <API key>;
case FUTEX_WAKE_BITSET:
return futex_wake(uaddr, flags, val, val3);
case FUTEX_REQUEUE:
return futex_requeue(uaddr, flags, uaddr2, val, val2, NULL, 0);
case FUTEX_CMP_REQUEUE:
return futex_requeue(uaddr, flags, uaddr2, val, val2, &val3, 0);
case FUTEX_WAKE_OP:
return futex_wake_op(uaddr, flags, uaddr2, val, val2, val3);
case FUTEX_LOCK_PI:
return futex_lock_pi(uaddr, flags, val, timeout, 0);
case FUTEX_UNLOCK_PI:
return futex_unlock_pi(uaddr, flags);
case FUTEX_TRYLOCK_PI:
return futex_lock_pi(uaddr, flags, 0, timeout, 1);
case <API key>:
val3 = <API key>;
return <API key>(uaddr, flags, val, timeout, val3,
uaddr2);
case <API key>:
return futex_requeue(uaddr, flags, uaddr2, val, val2, &val3, 1);
}
return -ENOSYS;
}
SYSCALL_DEFINE6(futex, u32 __user *, uaddr, int, op, u32, val,
struct timespec __user *, utime, u32 __user *, uaddr2,
u32, val3)
{
struct timespec ts;
ktime_t t, *tp = NULL;
u32 val2 = 0;
int cmd = op & FUTEX_CMD_MASK;
if (utime && (cmd == FUTEX_WAIT || cmd == FUTEX_LOCK_PI ||
cmd == FUTEX_WAIT_BITSET ||
cmd == <API key>)) {
if (copy_from_user(&ts, utime, sizeof(ts)) != 0)
return -EFAULT;
if (!timespec_valid(&ts))
return -EINVAL;
t = timespec_to_ktime(ts);
if (cmd == FUTEX_WAIT)
t = ktime_add_safe(ktime_get(), t);
tp = &t;
}
/*
* requeue parameter in 'utime' if cmd == FUTEX_*_REQUEUE_*.
* number of waiters to wake in 'utime' if cmd == FUTEX_WAKE_OP.
*/
if (cmd == FUTEX_REQUEUE || cmd == FUTEX_CMP_REQUEUE ||
cmd == <API key> || cmd == FUTEX_WAKE_OP)
val2 = (u32) (unsigned long) utime;
return do_futex(uaddr, op, val, tp, uaddr2, val2, val3);
}
static void __init <API key>(void)
{
#ifndef <API key>
u32 curval;
/*
* This will fail and we want it. Some arch implementations do
* runtime detection of the <API key>()
* functionality. We want to know that before we call in any
* of the complex code paths. Also we want to prevent
* registration of robust lists in that case. NULL is
* guaranteed to fault and we get -EFAULT on functional
* implementation, the non-functional ones will return
* -ENOSYS.
*/
if (<API key>(&curval, NULL, 0, 0) == -EFAULT)
<API key> = 1;
#endif
}
static int __init futex_init(void)
{
int i;
<API key>();
for (i = 0; i < ARRAY_SIZE(futex_queues); i++) {
plist_head_init(&futex_queues[i].chain);
spin_lock_init(&futex_queues[i].lock);
}
return 0;
}
__initcall(futex_init);
|
/* Automatically generated from ../src/remote/remote_protocol.x by gendispatch.pl.
* Do not edit this file. Any changes you make will be lost.
*/
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
remote_<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
char *cpu;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((cpu = <API key>(priv->conn, (const char **) args->xmlCPUs.xmlCPUs_val, args->xmlCPUs.xmlCPUs_len, args->flags)) == NULL)
goto cleanup;
ret->cpu = cpu;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
int result;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((result = <API key>(priv->conn, args->xml, args->flags)) < 0)
goto cleanup;
ret->result = result;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
char *domainXml;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((domainXml = <API key>(priv->conn, args->nativeFormat, args->nativeConfig, args->flags)) == NULL)
goto cleanup;
ret->domainXml = domainXml;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
char *nativeConfig;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((nativeConfig = <API key>(priv->conn, args->nativeFormat, args->domainXml, args->flags)) == NULL)
goto cleanup;
ret->nativeConfig = nativeConfig;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
char *srcSpec;
char *xml;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
srcSpec = args->srcSpec ? *args->srcSpec : NULL;
if ((xml = <API key>(priv->conn, args->type, srcSpec, args->flags)) == NULL)
goto cleanup;
ret->xml = xml;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *ret)
{
int rv = -1;
char *capabilities;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((capabilities = <API key>(priv->conn)) == NULL)
goto cleanup;
ret->capabilities = capabilities;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *ret)
{
int rv = -1;
char *hostname;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((hostname = <API key>(priv->conn)) == NULL)
goto cleanup;
ret->hostname = hostname;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *ret)
{
int rv = -1;
unsigned long lib_ver;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (<API key>(priv->conn, &lib_ver) < 0)
goto cleanup;
HYPER_TO_ULONG(ret->lib_ver, lib_ver);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
char *type;
int max_vcpus;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
type = args->type ? *args->type : NULL;
if ((max_vcpus = <API key>(priv->conn, type)) < 0)
goto cleanup;
ret->max_vcpus = max_vcpus;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
char *sysinfo;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((sysinfo = <API key>(priv->conn, args->flags)) == NULL)
goto cleanup;
ret->sysinfo = sysinfo;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *ret)
{
int rv = -1;
const char *type;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((type = virConnectGetType(priv->conn)) == NULL)
goto cleanup;
/* We have to VIR_STRDUP because <API key> will
* free this string after it's been serialised. */
if (VIR_STRDUP(ret->type, type) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *ret)
{
int rv = -1;
char *uri;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((uri = virConnectGetURI(priv->conn)) == NULL)
goto cleanup;
ret->uri = uri;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *ret)
{
int rv = -1;
unsigned long hv_ver;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (<API key>(priv->conn, &hv_ver) < 0)
goto cleanup;
HYPER_TO_ULONG(ret->hv_ver, hv_ver);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *ret)
{
int rv = -1;
int secure;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((secure = virConnectIsSecure(priv->conn)) < 0)
goto cleanup;
ret->secure = secure;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
int len;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > <API key>) {
virReportError(<API key>,
"%s", _("maxnames > <API key>"));
goto cleanup;
}
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = <API key>(priv->conn, ret->names.names_val, args->maxnames)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
<API key>(rerr);
VIR_FREE(ret->names.names_val);
}
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
int len;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > <API key>) {
virReportError(<API key>,
"%s", _("maxnames > <API key>"));
goto cleanup;
}
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = <API key>(priv->conn, ret->names.names_val, args->maxnames)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
<API key>(rerr);
VIR_FREE(ret->names.names_val);
}
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
int len;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > <API key>) {
virReportError(<API key>,
"%s", _("maxnames > <API key>"));
goto cleanup;
}
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = <API key>(priv->conn, ret->names.names_val, args->maxnames)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
<API key>(rerr);
VIR_FREE(ret->names.names_val);
}
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
int len;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > <API key>) {
virReportError(<API key>,
"%s", _("maxnames > <API key>"));
goto cleanup;
}
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = <API key>(priv->conn, ret->names.names_val, args->maxnames)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
<API key>(rerr);
VIR_FREE(ret->names.names_val);
}
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
int len;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxids > <API key>) {
virReportError(<API key>,
"%s", _("maxids > <API key>"));
goto cleanup;
}
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->ids.ids_val, args->maxids) < 0)
goto cleanup;
if ((len = <API key>(priv->conn, ret->ids.ids_val, args->maxids)) < 0)
goto cleanup;
ret->ids.ids_len = len;
rv = 0;
cleanup:
if (rv < 0) {
<API key>(rerr);
VIR_FREE(ret->ids.ids_val);
}
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
int len;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > <API key>) {
virReportError(<API key>,
"%s", _("maxnames > <API key>"));
goto cleanup;
}
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = <API key>(priv->conn, ret->names.names_val, args->maxnames)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
<API key>(rerr);
VIR_FREE(ret->names.names_val);
}
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
int len;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > <API key>) {
virReportError(<API key>,
"%s", _("maxnames > <API key>"));
goto cleanup;
}
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = <API key>(priv->conn, ret->names.names_val, args->maxnames)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
<API key>(rerr);
VIR_FREE(ret->names.names_val);
}
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
int len;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > <API key>) {
virReportError(<API key>,
"%s", _("maxnames > <API key>"));
goto cleanup;
}
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = <API key>(priv->conn, ret->names.names_val, args->maxnames)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
<API key>(rerr);
VIR_FREE(ret->names.names_val);
}
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
int len;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxuuids > <API key>) {
virReportError(<API key>,
"%s", _("maxuuids > <API key>"));
goto cleanup;
}
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->uuids.uuids_val, args->maxuuids) < 0)
goto cleanup;
if ((len = <API key>(priv->conn, ret->uuids.uuids_val, args->maxuuids)) < 0)
goto cleanup;
ret->uuids.uuids_len = len;
rv = 0;
cleanup:
if (rv < 0) {
<API key>(rerr);
VIR_FREE(ret->uuids.uuids_val);
}
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
int len;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > <API key>) {
virReportError(<API key>,
"%s", _("maxnames > <API key>"));
goto cleanup;
}
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = <API key>(priv->conn, ret->names.names_val, args->maxnames)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
<API key>(rerr);
VIR_FREE(ret->names.names_val);
}
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *ret)
{
int rv = -1;
int num;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((num = <API key>(priv->conn)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *ret)
{
int rv = -1;
int num;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((num = <API key>(priv->conn)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *ret)
{
int rv = -1;
int num;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((num = <API key>(priv->conn)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *ret)
{
int rv = -1;
int num;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((num = <API key>(priv->conn)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *ret)
{
int rv = -1;
int num;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((num = <API key>(priv->conn)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *ret)
{
int rv = -1;
int num;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((num = <API key>(priv->conn)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *ret)
{
int rv = -1;
int num;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((num = <API key>(priv->conn)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *ret)
{
int rv = -1;
int num;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((num = <API key>(priv->conn)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *ret)
{
int rv = -1;
int num;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((num = <API key>(priv->conn)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *ret)
{
int rv = -1;
int num;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((num = <API key>(priv->conn)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainAbortJob(dom) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->xml) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->xml, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
char *base;
char *top;
unsigned long bandwidth;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
HYPER_TO_ULONG(bandwidth, args->bandwidth);
base = args->base ? *args->base : NULL;
top = args->top ? *args->top : NULL;
if (<API key>(dom, args->disk, base, top, bandwidth, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->path, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
unsigned long bandwidth;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
HYPER_TO_ULONG(bandwidth, args->bandwidth);
if (<API key>(dom, args->path, bandwidth, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
unsigned long bandwidth;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
HYPER_TO_ULONG(bandwidth, args->bandwidth);
if (virDomainBlockPull(dom, args->path, bandwidth, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
char *base;
unsigned long bandwidth;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
HYPER_TO_ULONG(bandwidth, args->bandwidth);
base = args->base ? *args->base : NULL;
if (<API key>(dom, args->path, base, bandwidth, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->disk, args->size, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
<API key> tmp;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainBlockStats(dom, args->path, &tmp, sizeof(tmp)) < 0)
goto cleanup;
ret->rd_req = tmp.rd_req;
ret->rd_bytes = tmp.rd_bytes;
ret->wr_req = tmp.wr_req;
ret->wr_bytes = tmp.wr_bytes;
ret->errs = tmp.errs;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainCoreDump(dom, args->to, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->to, args->dumpformat, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainCreate(dom) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->flags) < 0)
goto cleanup;
make_nonnull_domain(&ret->dom, dom);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((dom = virDomainCreateXML(priv->conn, args->xml_desc, args->flags)) == NULL)
goto cleanup;
make_nonnull_domain(&ret->dom, dom);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((dom = virDomainDefineXML(priv->conn, args->xml)) == NULL)
goto cleanup;
make_nonnull_domain(&ret->dom, dom);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainDestroy(dom) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->xml) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->xml, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
char *mountPoint;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
mountPoint = args->mountPoint ? *args->mountPoint : NULL;
if (virDomainFSTrim(dom, mountPoint, args->minimum, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
int autostart;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, &autostart) < 0)
goto cleanup;
ret->autostart = autostart;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
virDomainBlockInfo tmp;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->path, &tmp, args->flags) < 0)
goto cleanup;
ret->allocation = tmp.allocation;
ret->capacity = tmp.capacity;
ret->physical = tmp.physical;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
<API key> tmp;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, &tmp, args->flags) < 0)
goto cleanup;
ret->state = tmp.state;
ret->details = tmp.details;
ret->stateTime = tmp.stateTime;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
char *hostname;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((hostname = <API key>(dom, args->flags)) == NULL)
goto cleanup;
ret->hostname = hostname;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
virDomainInfo tmp;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainGetInfo(dom, &tmp) < 0)
goto cleanup;
ret->state = tmp.state;
ret->maxMem = tmp.maxMem;
ret->memory = tmp.memory;
ret->nrVirtCpu = tmp.nrVirtCpu;
ret->cpuTime = tmp.cpuTime;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
virDomainJobInfo tmp;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainGetJobInfo(dom, &tmp) < 0)
goto cleanup;
ret->type = tmp.type;
ret->timeElapsed = tmp.timeElapsed;
ret->timeRemaining = tmp.timeRemaining;
ret->dataTotal = tmp.dataTotal;
ret->dataProcessed = tmp.dataProcessed;
ret->dataRemaining = tmp.dataRemaining;
ret->memTotal = tmp.memTotal;
ret->memProcessed = tmp.memProcessed;
ret->memRemaining = tmp.memRemaining;
ret->fileTotal = tmp.fileTotal;
ret->fileProcessed = tmp.fileProcessed;
ret->fileRemaining = tmp.fileRemaining;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
unsigned long long memory;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((memory = <API key>(dom)) == 0)
goto cleanup;
ret->memory = memory;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
int num;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((num = <API key>(dom)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
char *uri;
char *metadata;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
uri = args->uri ? *args->uri : NULL;
if ((metadata = <API key>(dom, args->type, uri, args->flags)) == NULL)
goto cleanup;
ret->metadata = metadata;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
char *type;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((type = virDomainGetOSType(dom)) == NULL)
goto cleanup;
ret->type = type;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
int num;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((num = <API key>(dom, args->flags)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
char *xml;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((xml = virDomainGetXMLDesc(dom, args->flags)) == NULL)
goto cleanup;
ret->xml = xml;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
int result;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((result = <API key>(dom, args->flags)) < 0)
goto cleanup;
ret->result = result;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
int result;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((result = <API key>(dom, args->flags)) < 0)
goto cleanup;
ret->result = result;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainInjectNMI(dom, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
<API key> tmp;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->path, &tmp, sizeof(tmp)) < 0)
goto cleanup;
ret->rx_bytes = tmp.rx_bytes;
ret->rx_packets = tmp.rx_packets;
ret->rx_errs = tmp.rx_errs;
ret->rx_drop = tmp.rx_drop;
ret->tx_bytes = tmp.tx_bytes;
ret->tx_packets = tmp.tx_packets;
ret->tx_errs = tmp.tx_errs;
ret->tx_drop = tmp.tx_drop;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
int active;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((active = virDomainIsActive(dom)) < 0)
goto cleanup;
ret->active = active;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
int persistent;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((persistent = <API key>(dom)) < 0)
goto cleanup;
ret->persistent = persistent;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
int updated;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((updated = virDomainIsUpdated(dom)) < 0)
goto cleanup;
ret->updated = updated;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((dom = virDomainLookupByID(priv->conn, args->id)) == NULL)
goto cleanup;
make_nonnull_domain(&ret->dom, dom);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((dom = <API key>(priv->conn, args->name)) == NULL)
goto cleanup;
make_nonnull_domain(&ret->dom, dom);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((dom = <API key>(priv->conn, (unsigned char *) args->uuid)) == NULL)
goto cleanup;
make_nonnull_domain(&ret->dom, dom);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
unsigned long flags;
virDomainPtr ddom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
HYPER_TO_ULONG(flags, args->flags);
if ((ddom = <API key>(priv->conn, args->dname, args->cookie.cookie_val, args->cookie.cookie_len, args->uri, flags)) == NULL)
goto cleanup;
make_nonnull_domain(&ret->ddom, ddom);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (ddom)
virDomainFree(ddom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
unsigned long flags;
virDomainPtr ddom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
HYPER_TO_ULONG(flags, args->flags);
if ((ddom = <API key>(priv->conn, args->dname, args->cookie.cookie_val, args->cookie.cookie_len, args->uri, flags, args->retcode)) == NULL)
goto cleanup;
make_nonnull_domain(&ret->ddom, ddom);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (ddom)
virDomainFree(ddom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
unsigned long long cacheSize;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, &cacheSize, args->flags) < 0)
goto cleanup;
ret->cacheSize = cacheSize;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
unsigned long bandwidth;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, &bandwidth, args->flags) < 0)
goto cleanup;
HYPER_TO_ULONG(ret->bandwidth, bandwidth);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
unsigned long flags;
char *dname;
unsigned long resource;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
HYPER_TO_ULONG(flags, args->flags);
HYPER_TO_ULONG(resource, args->resource);
dname = args->dname ? *args->dname : NULL;
if (<API key>(dom, args->cookie.cookie_val, args->cookie.cookie_len, args->uri, flags, dname, resource) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
unsigned long flags;
char *dname;
unsigned long resource;
struct daemonClientPrivate *priv =
<API key>(client);
virStreamPtr st = NULL;
<API key> stream = NULL;
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
HYPER_TO_ULONG(flags, args->flags);
HYPER_TO_ULONG(resource, args->resource);
dname = args->dname ? *args->dname : NULL;
if (!(st = virStreamNew(priv->conn, VIR_STREAM_NONBLOCK)))
goto cleanup;
if (!(stream = <API key>(client, st, remoteProgram, &msg->header)))
goto cleanup;
if (<API key>(priv->conn, st, flags, dname, resource, args->dom_xml) < 0)
goto cleanup;
if (<API key>(client, stream, false) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0) {
<API key>(rerr);
if (stream) {
virStreamAbort(st);
<API key>(client, stream);
} else {
virStreamFree(st);
}
}
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
unsigned long flags;
char *dname;
unsigned long resource;
char *cookie_out = NULL;
int cookie_out_len = 0;
struct daemonClientPrivate *priv =
<API key>(client);
virStreamPtr st = NULL;
<API key> stream = NULL;
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
HYPER_TO_ULONG(flags, args->flags);
HYPER_TO_ULONG(resource, args->resource);
dname = args->dname ? *args->dname : NULL;
if (!(st = virStreamNew(priv->conn, VIR_STREAM_NONBLOCK)))
goto cleanup;
if (!(stream = <API key>(client, st, remoteProgram, &msg->header)))
goto cleanup;
if (<API key>(priv->conn, st, args->cookie_in.cookie_in_val, args->cookie_in.cookie_in_len, &cookie_out, &cookie_out_len, flags, dname, resource, args->dom_xml) < 0)
goto cleanup;
if (<API key>(client, stream, false) < 0)
goto cleanup;
ret->cookie_out.cookie_out_val = cookie_out;
ret->cookie_out.cookie_out_len = cookie_out_len;
rv = 0;
cleanup:
if (rv < 0) {
<API key>(rerr);
VIR_FREE(cookie_out);
if (stream) {
virStreamAbort(st);
<API key>(client, stream);
} else {
virStreamFree(st);
}
}
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->cacheSize, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->downtime, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
unsigned long bandwidth;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
HYPER_TO_ULONG(bandwidth, args->bandwidth);
if (<API key>(dom, bandwidth, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
char *name;
struct daemonClientPrivate *priv =
<API key>(client);
virStreamPtr st = NULL;
<API key> stream = NULL;
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
name = args->name ? *args->name : NULL;
if (!(st = virStreamNew(priv->conn, VIR_STREAM_NONBLOCK)))
goto cleanup;
if (!(stream = <API key>(client, st, remoteProgram, &msg->header)))
goto cleanup;
if (<API key>(dom, name, st, args->flags) < 0)
goto cleanup;
if (<API key>(client, stream, true) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0) {
<API key>(rerr);
if (stream) {
virStreamAbort(st);
<API key>(client, stream);
} else {
virStreamFree(st);
}
}
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
char *dev_name;
struct daemonClientPrivate *priv =
<API key>(client);
virStreamPtr st = NULL;
<API key> stream = NULL;
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
dev_name = args->dev_name ? *args->dev_name : NULL;
if (!(st = virStreamNew(priv->conn, VIR_STREAM_NONBLOCK)))
goto cleanup;
if (!(stream = <API key>(client, st, remoteProgram, &msg->header)))
goto cleanup;
if (<API key>(dom, dev_name, st, args->flags) < 0)
goto cleanup;
if (<API key>(client, stream, true) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0) {
<API key>(rerr);
if (stream) {
virStreamAbort(st);
<API key>(client, stream);
} else {
virStreamFree(st);
}
}
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainPinVcpu(dom, args->vcpu, (unsigned char *) args->cpumap.cpumap_val, args->cpumap.cpumap_len) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->vcpu, (unsigned char *) args->cpumap.cpumap_val, args->cpumap.cpumap_len, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->target, args->duration, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainPMWakeup(dom, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainReboot(dom, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainReset(dom, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (virDomainRestore(priv->conn, args->from) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
char *dxml;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
dxml = args->dxml ? *args->dxml : NULL;
if (<API key>(priv->conn, args->from, dxml, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainResume(dom) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
<API key> snapshot = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->snap.dom)))
goto cleanup;
if (!(snapshot = <API key>(dom, args->snap)))
goto cleanup;
if (<API key>(snapshot, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (snapshot)
<API key>(snapshot);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainSave(dom, args->to) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
char *dxml;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
dxml = args->dxml ? *args->dxml : NULL;
if (virDomainSaveFlags(dom, args->to, dxml, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (<API key>(priv->conn, args->file, args->dxml, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
char *xml;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((xml = <API key>(priv->conn, args->file, args->flags)) == NULL)
goto cleanup;
ret->xml = xml;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
char *mime = NULL;
char **mime_p = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
virStreamPtr st = NULL;
<API key> stream = NULL;
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (!(st = virStreamNew(priv->conn, VIR_STREAM_NONBLOCK)))
goto cleanup;
if (!(stream = <API key>(client, st, remoteProgram, &msg->header)))
goto cleanup;
if ((mime = virDomainScreenshot(dom, st, args->screen, args->flags)) == NULL)
goto cleanup;
if (<API key>(client, stream, true) < 0)
goto cleanup;
if (VIR_ALLOC(mime_p) < 0)
goto cleanup;
if (VIR_STRDUP(*mime_p, mime) < 0)
goto cleanup;
ret->mime = mime_p;
rv = 0;
cleanup:
if (rv < 0) {
<API key>(rerr);
VIR_FREE(mime_p);
if (stream) {
virStreamAbort(st);
<API key>(client, stream);
} else {
virStreamFree(st);
}
}
if (dom)
virDomainFree(dom);
VIR_FREE(mime);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainSendKey(dom, args->codeset, args->holdtime, args->keycodes.keycodes_val, args->keycodes.keycodes_len, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->pid_value, args->signum, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->autostart) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
<API key> params = NULL;
int nparams = 0;;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((params = <API key>(args->params.params_val,
args->params.params_len,
<API key>,
&nparams)) == NULL)
goto cleanup;
if (<API key>(dom, params, nparams, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
virTypedParamsFree(params, nparams);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
<API key> params = NULL;
int nparams = 0;;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((params = <API key>(args->params.params_val,
args->params.params_len,
<API key>,
&nparams)) == NULL)
goto cleanup;
if (<API key>(dom, args->disk, params, nparams, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
virTypedParamsFree(params, nparams);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
<API key> params = NULL;
int nparams = 0;;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((params = <API key>(args->params.params_val,
args->params.params_len,
<API key>,
&nparams)) == NULL)
goto cleanup;
if (<API key>(dom, args->device, params, nparams, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
virTypedParamsFree(params, nparams);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
unsigned long memory;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
HYPER_TO_ULONG(memory, args->memory);
if (<API key>(dom, memory) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
unsigned long memory;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
HYPER_TO_ULONG(memory, args->memory);
if (virDomainSetMemory(dom, memory) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
unsigned long memory;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
HYPER_TO_ULONG(memory, args->memory);
if (<API key>(dom, memory, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
<API key> params = NULL;
int nparams = 0;;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((params = <API key>(args->params.params_val,
args->params.params_len,
<API key>,
&nparams)) == NULL)
goto cleanup;
if (<API key>(dom, params, nparams, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
virTypedParamsFree(params, nparams);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->period, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
char *metadata;
char *key;
char *uri;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
metadata = args->metadata ? *args->metadata : NULL;
key = args->key ? *args->key : NULL;
uri = args->uri ? *args->uri : NULL;
if (<API key>(dom, args->type, metadata, key, uri, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
<API key> params = NULL;
int nparams = 0;;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((params = <API key>(args->params.params_val,
args->params.params_len,
<API key>,
&nparams)) == NULL)
goto cleanup;
if (<API key>(dom, params, nparams, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
virTypedParamsFree(params, nparams);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
<API key> params = NULL;
int nparams = 0;;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((params = <API key>(args->params.params_val,
args->params.params_len,
<API key>,
&nparams)) == NULL)
goto cleanup;
if (<API key>(dom, params, nparams) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
virTypedParamsFree(params, nparams);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
<API key> params = NULL;
int nparams = 0;;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((params = <API key>(args->params.params_val,
args->params.params_len,
<API key>,
&nparams)) == NULL)
goto cleanup;
if (<API key>(dom, params, nparams, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
virTypedParamsFree(params, nparams);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainSetVcpus(dom, args->nvcpus) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->nvcpus, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainShutdown(dom) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
<API key> snap = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((snap = <API key>(dom, args->xml_desc, args->flags)) == NULL)
goto cleanup;
<API key>(&ret->snap, snap);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
if (snap)
<API key>(snap);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
<API key> snap = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((snap = <API key>(dom, args->flags)) == NULL)
goto cleanup;
<API key>(&ret->snap, snap);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
if (snap)
<API key>(snap);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
<API key> snapshot = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->snap.dom)))
goto cleanup;
if (!(snapshot = <API key>(dom, args->snap)))
goto cleanup;
if (<API key>(snapshot, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (snapshot)
<API key>(snapshot);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
<API key> snapshot = NULL;
<API key> snap = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->snap.dom)))
goto cleanup;
if (!(snapshot = <API key>(dom, args->snap)))
goto cleanup;
if ((snap = <API key>(snapshot, args->flags)) == NULL)
goto cleanup;
<API key>(&ret->snap, snap);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (snapshot)
<API key>(snapshot);
if (dom)
virDomainFree(dom);
if (snap)
<API key>(snap);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
<API key> snapshot = NULL;
char *xml;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->snap.dom)))
goto cleanup;
if (!(snapshot = <API key>(dom, args->snap)))
goto cleanup;
if ((xml = <API key>(snapshot, args->flags)) == NULL)
goto cleanup;
ret->xml = xml;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (snapshot)
<API key>(snapshot);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
<API key> snapshot = NULL;
int metadata;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->snap.dom)))
goto cleanup;
if (!(snapshot = <API key>(dom, args->snap)))
goto cleanup;
if ((metadata = <API key>(snapshot, args->flags)) < 0)
goto cleanup;
ret->metadata = metadata;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (snapshot)
<API key>(snapshot);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
<API key> snapshot = NULL;
int current;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->snap.dom)))
goto cleanup;
if (!(snapshot = <API key>(dom, args->snap)))
goto cleanup;
if ((current = <API key>(snapshot, args->flags)) < 0)
goto cleanup;
ret->current = current;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (snapshot)
<API key>(snapshot);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
<API key> snapshot = NULL;
int len;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > <API key>) {
virReportError(<API key>,
"%s", _("maxnames > <API key>"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->snap.dom)))
goto cleanup;
if (!(snapshot = <API key>(dom, args->snap)))
goto cleanup;
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = <API key>(snapshot, ret->names.names_val, args->maxnames, args->flags)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
<API key>(rerr);
VIR_FREE(ret->names.names_val);
}
if (snapshot)
<API key>(snapshot);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
int len;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > <API key>) {
virReportError(<API key>,
"%s", _("maxnames > <API key>"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = <API key>(dom, ret->names.names_val, args->maxnames, args->flags)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
<API key>(rerr);
VIR_FREE(ret->names.names_val);
}
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
<API key> snap = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((snap = <API key>(dom, args->name, args->flags)) == NULL)
goto cleanup;
<API key>(&ret->snap, snap);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
if (snap)
<API key>(snap);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
int num;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if ((num = <API key>(dom, args->flags)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virDomainPtr dom = NULL;
<API key> snapshot = NULL;
int num;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->snap.dom)))
goto cleanup;
if (!(snapshot = <API key>(dom, args->snap)))
goto cleanup;
if ((num = <API key>(snapshot, args->flags)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (snapshot)
<API key>(snapshot);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainSuspend(dom) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (virDomainUndefine(dom) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virDomainPtr dom = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dom = get_nonnull_domain(priv->conn, args->dom)))
goto cleanup;
if (<API key>(dom, args->xml, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dom)
virDomainFree(dom);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (<API key>(priv->conn, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (<API key>(priv->conn, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (<API key>(priv->conn, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virInterfacePtr iface = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(iface = <API key>(priv->conn, args->iface)))
goto cleanup;
if (virInterfaceCreate(iface, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (iface)
virInterfaceFree(iface);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virInterfacePtr iface = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((iface = <API key>(priv->conn, args->xml, args->flags)) == NULL)
goto cleanup;
<API key>(&ret->iface, iface);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (iface)
virInterfaceFree(iface);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virInterfacePtr iface = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(iface = <API key>(priv->conn, args->iface)))
goto cleanup;
if (virInterfaceDestroy(iface, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (iface)
virInterfaceFree(iface);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virInterfacePtr iface = NULL;
char *xml;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(iface = <API key>(priv->conn, args->iface)))
goto cleanup;
if ((xml = <API key>(iface, args->flags)) == NULL)
goto cleanup;
ret->xml = xml;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (iface)
virInterfaceFree(iface);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virInterfacePtr iface = NULL;
int active;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(iface = <API key>(priv->conn, args->iface)))
goto cleanup;
if ((active = <API key>(iface)) < 0)
goto cleanup;
ret->active = active;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (iface)
virInterfaceFree(iface);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virInterfacePtr iface = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((iface = <API key>(priv->conn, args->mac)) == NULL)
goto cleanup;
<API key>(&ret->iface, iface);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (iface)
virInterfaceFree(iface);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virInterfacePtr iface = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((iface = <API key>(priv->conn, args->name)) == NULL)
goto cleanup;
<API key>(&ret->iface, iface);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (iface)
virInterfaceFree(iface);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virInterfacePtr iface = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(iface = <API key>(priv->conn, args->iface)))
goto cleanup;
if (<API key>(iface) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (iface)
virInterfaceFree(iface);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virNetworkPtr net = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(net = get_nonnull_network(priv->conn, args->net)))
goto cleanup;
if (virNetworkCreate(net) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virNetworkPtr net = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((net = virNetworkCreateXML(priv->conn, args->xml)) == NULL)
goto cleanup;
<API key>(&ret->net, net);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virNetworkPtr net = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((net = virNetworkDefineXML(priv->conn, args->xml)) == NULL)
goto cleanup;
<API key>(&ret->net, net);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virNetworkPtr net = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(net = get_nonnull_network(priv->conn, args->net)))
goto cleanup;
if (virNetworkDestroy(net) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virNetworkPtr net = NULL;
int autostart;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(net = get_nonnull_network(priv->conn, args->net)))
goto cleanup;
if (<API key>(net, &autostart) < 0)
goto cleanup;
ret->autostart = autostart;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virNetworkPtr net = NULL;
char *name;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(net = get_nonnull_network(priv->conn, args->net)))
goto cleanup;
if ((name = <API key>(net)) == NULL)
goto cleanup;
ret->name = name;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virNetworkPtr net = NULL;
char *xml;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(net = get_nonnull_network(priv->conn, args->net)))
goto cleanup;
if ((xml = <API key>(net, args->flags)) == NULL)
goto cleanup;
ret->xml = xml;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virNetworkPtr net = NULL;
int active;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(net = get_nonnull_network(priv->conn, args->net)))
goto cleanup;
if ((active = virNetworkIsActive(net)) < 0)
goto cleanup;
ret->active = active;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virNetworkPtr net = NULL;
int persistent;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(net = get_nonnull_network(priv->conn, args->net)))
goto cleanup;
if ((persistent = <API key>(net)) < 0)
goto cleanup;
ret->persistent = persistent;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virNetworkPtr net = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((net = <API key>(priv->conn, args->name)) == NULL)
goto cleanup;
<API key>(&ret->net, net);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virNetworkPtr net = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((net = <API key>(priv->conn, (unsigned char *) args->uuid)) == NULL)
goto cleanup;
<API key>(&ret->net, net);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virNetworkPtr net = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(net = get_nonnull_network(priv->conn, args->net)))
goto cleanup;
if (<API key>(net, args->autostart) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virNetworkPtr net = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(net = get_nonnull_network(priv->conn, args->net)))
goto cleanup;
if (virNetworkUndefine(net) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virNetworkPtr net = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(net = get_nonnull_network(priv->conn, args->net)))
goto cleanup;
if (virNetworkUpdate(net, args->command, args->section, args->parentIndex, args->xml, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (net)
virNetworkFree(net);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virNodeDevicePtr dev = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((dev = <API key>(priv->conn, args->xml_desc, args->flags)) == NULL)
goto cleanup;
<API key>(&ret->dev, dev);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dev)
virNodeDeviceFree(dev);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virNodeDevicePtr dev = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dev = <API key>(priv->conn, args->name)))
goto cleanup;
if (<API key>(dev) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dev)
virNodeDeviceFree(dev);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virNodeDevicePtr dev = NULL;
char *driverName;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dev = <API key>(priv->conn, args->name)))
goto cleanup;
driverName = args->driverName ? *args->driverName : NULL;
if (<API key>(dev, driverName, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dev)
virNodeDeviceFree(dev);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virNodeDevicePtr dev = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dev = <API key>(priv->conn, args->name)))
goto cleanup;
if (<API key>(dev) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dev)
virNodeDeviceFree(dev);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virNodeDevicePtr dev = NULL;
char *xml;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dev = <API key>(priv->conn, args->name)))
goto cleanup;
if ((xml = <API key>(dev, args->flags)) == NULL)
goto cleanup;
ret->xml = xml;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dev)
virNodeDeviceFree(dev);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virNodeDevicePtr dev = NULL;
int len;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > <API key>) {
virReportError(<API key>,
"%s", _("maxnames > <API key>"));
goto cleanup;
}
if (!(dev = <API key>(priv->conn, args->name)))
goto cleanup;
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = <API key>(dev, ret->names.names_val, args->maxnames)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
<API key>(rerr);
VIR_FREE(ret->names.names_val);
}
if (dev)
virNodeDeviceFree(dev);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virNodeDevicePtr dev = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((dev = <API key>(priv->conn, args->name)) == NULL)
goto cleanup;
<API key>(&ret->dev, dev);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dev)
virNodeDeviceFree(dev);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virNodeDevicePtr dev = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((dev = <API key>(priv->conn, args->wwnn, args->wwpn, args->flags)) == NULL)
goto cleanup;
<API key>(&ret->dev, dev);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dev)
virNodeDeviceFree(dev);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virNodeDevicePtr dev = NULL;
int num;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dev = <API key>(priv->conn, args->name)))
goto cleanup;
if ((num = <API key>(dev)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dev)
virNodeDeviceFree(dev);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virNodeDevicePtr dev = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dev = <API key>(priv->conn, args->name)))
goto cleanup;
if (<API key>(dev) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dev)
virNodeDeviceFree(dev);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virNodeDevicePtr dev = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(dev = <API key>(priv->conn, args->name)))
goto cleanup;
if (virNodeDeviceReset(dev) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (dev)
virNodeDeviceFree(dev);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
int len;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxcells > <API key>) {
virReportError(<API key>,
"%s", _("maxcells > <API key>"));
goto cleanup;
}
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->cells.cells_val, args->maxcells) < 0)
goto cleanup;
if ((len = <API key>(priv->conn, (unsigned long long *)ret->cells.cells_val, args->startCell, args->maxcells)) <= 0)
goto cleanup;
ret->cells.cells_len = len;
rv = 0;
cleanup:
if (rv < 0) {
<API key>(rerr);
VIR_FREE(ret->cells.cells_val);
}
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *ret)
{
int rv = -1;
unsigned long long freeMem;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((freeMem = <API key>(priv->conn)) == 0)
goto cleanup;
ret->freeMem = freeMem;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *ret)
{
int rv = -1;
virNodeInfo tmp;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (virNodeGetInfo(priv->conn, &tmp) < 0)
goto cleanup;
memcpy(ret->model, tmp.model, sizeof(ret->model));
ret->memory = tmp.memory;
ret->cpus = tmp.cpus;
ret->mhz = tmp.mhz;
ret->nodes = tmp.nodes;
ret->sockets = tmp.sockets;
ret->cores = tmp.cores;
ret->threads = tmp.threads;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args ATTRIBUTE_UNUSED,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
char *cap;
int len;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > <API key>) {
virReportError(<API key>,
"%s", _("maxnames > <API key>"));
goto cleanup;
}
cap = args->cap ? *args->cap : NULL;
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = virNodeListDevices(priv->conn, cap, ret->names.names_val, args->maxnames, args->flags)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
<API key>(rerr);
VIR_FREE(ret->names.names_val);
}
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
char *cap;
int num;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
cap = args->cap ? *args->cap : NULL;
if ((num = virNodeNumOfDevices(priv->conn, cap, args->flags)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
<API key> params = NULL;
int nparams = 0;;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((params = <API key>(args->params.params_val,
args->params.params_len,
<API key>,
&nparams)) == NULL)
goto cleanup;
if (<API key>(priv->conn, params, nparams, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
virTypedParamsFree(params, nparams);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (<API key>(priv->conn, args->target, args->duration, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virNWFilterPtr nwfilter = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((nwfilter = <API key>(priv->conn, args->xml)) == NULL)
goto cleanup;
<API key>(&ret->nwfilter, nwfilter);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (nwfilter)
virNWFilterFree(nwfilter);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virNWFilterPtr nwfilter = NULL;
char *xml;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(nwfilter = <API key>(priv->conn, args->nwfilter)))
goto cleanup;
if ((xml = <API key>(nwfilter, args->flags)) == NULL)
goto cleanup;
ret->xml = xml;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (nwfilter)
virNWFilterFree(nwfilter);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virNWFilterPtr nwfilter = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((nwfilter = <API key>(priv->conn, args->name)) == NULL)
goto cleanup;
<API key>(&ret->nwfilter, nwfilter);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (nwfilter)
virNWFilterFree(nwfilter);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virNWFilterPtr nwfilter = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((nwfilter = <API key>(priv->conn, (unsigned char *) args->uuid)) == NULL)
goto cleanup;
<API key>(&ret->nwfilter, nwfilter);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (nwfilter)
virNWFilterFree(nwfilter);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virNWFilterPtr nwfilter = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(nwfilter = <API key>(priv->conn, args->nwfilter)))
goto cleanup;
if (virNWFilterUndefine(nwfilter) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (nwfilter)
virNWFilterFree(nwfilter);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
remote_<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
remote_<API key> *args,
<API key> *ret)
{
int rv = -1;
virSecretPtr secret = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((<API key>(priv->conn, args->xml, args->flags)) == NULL)
goto cleanup;
make_nonnull_secret(&ret->secret, secret);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (secret)
virSecretFree(secret);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
remote_<API key> *args,
remote_<API key> *ret);
static int remoteDispatch<API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
remote_<API key> *args,
remote_<API key> *ret)
{
int rv = -1;
virSecretPtr secret = NULL;
char *xml;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(<API key>(priv->conn, args->secret)))
goto cleanup;
if ((xml = virSecretGetXMLDesc(secret, args->flags)) == NULL)
goto cleanup;
ret->xml = xml;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (secret)
virSecretFree(secret);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
remote_<API key> *args,
remote_<API key> *ret);
static int remoteDispatch<API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
remote_<API key> *args,
remote_<API key> *ret)
{
int rv = -1;
virSecretPtr secret = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((<API key>(priv->conn, args->usageType, args->usageID)) == NULL)
goto cleanup;
make_nonnull_secret(&ret->secret, secret);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (secret)
virSecretFree(secret);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
remote_<API key> *args,
remote_<API key> *ret);
static int remoteDispatch<API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
remote_<API key> *args,
remote_<API key> *ret)
{
int rv = -1;
virSecretPtr secret = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((<API key>(priv->conn, (unsigned char *) args->uuid)) == NULL)
goto cleanup;
make_nonnull_secret(&ret->secret, secret);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (secret)
virSecretFree(secret);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virSecretPtr secret = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(<API key>(priv->conn, args->secret)))
goto cleanup;
if (virSecretSetValue(secret, (const unsigned char *) args->value.value_val, args->value.value_len, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (secret)
virSecretFree(secret);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virSecretPtr secret = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(<API key>(priv->conn, args->secret)))
goto cleanup;
if (virSecretUndefine(secret) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (secret)
virSecretFree(secret);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = <API key>(priv->conn, args->pool)))
goto cleanup;
if (virStoragePoolBuild(pool, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = <API key>(priv->conn, args->pool)))
goto cleanup;
if (<API key>(pool, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((pool = <API key>(priv->conn, args->xml, args->flags)) == NULL)
goto cleanup;
<API key>(&ret->pool, pool);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((pool = <API key>(priv->conn, args->xml, args->flags)) == NULL)
goto cleanup;
<API key>(&ret->pool, pool);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = <API key>(priv->conn, args->pool)))
goto cleanup;
if (<API key>(pool, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = <API key>(priv->conn, args->pool)))
goto cleanup;
if (<API key>(pool) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
int autostart;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = <API key>(priv->conn, args->pool)))
goto cleanup;
if (<API key>(pool, &autostart) < 0)
goto cleanup;
ret->autostart = autostart;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
virStoragePoolInfo tmp;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = <API key>(priv->conn, args->pool)))
goto cleanup;
if (<API key>(pool, &tmp) < 0)
goto cleanup;
ret->state = tmp.state;
ret->capacity = tmp.capacity;
ret->allocation = tmp.allocation;
ret->available = tmp.available;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
char *xml;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = <API key>(priv->conn, args->pool)))
goto cleanup;
if ((xml = <API key>(pool, args->flags)) == NULL)
goto cleanup;
ret->xml = xml;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
int active;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = <API key>(priv->conn, args->pool)))
goto cleanup;
if ((active = <API key>(pool)) < 0)
goto cleanup;
ret->active = active;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
int persistent;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = <API key>(priv->conn, args->pool)))
goto cleanup;
if ((persistent = <API key>(pool)) < 0)
goto cleanup;
ret->persistent = persistent;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
/* <API key> body has to be implemented manually */
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
int len;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (args->maxnames > <API key>) {
virReportError(<API key>,
"%s", _("maxnames > <API key>"));
goto cleanup;
}
if (!(pool = <API key>(priv->conn, args->pool)))
goto cleanup;
/* Allocate return buffer. */
if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0)
goto cleanup;
if ((len = <API key>(pool, ret->names.names_val, args->maxnames)) < 0)
goto cleanup;
ret->names.names_len = len;
rv = 0;
cleanup:
if (rv < 0) {
<API key>(rerr);
VIR_FREE(ret->names.names_val);
}
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((pool = <API key>(priv->conn, args->name)) == NULL)
goto cleanup;
<API key>(&ret->pool, pool);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((pool = <API key>(priv->conn, (unsigned char *) args->uuid)) == NULL)
goto cleanup;
<API key>(&ret->pool, pool);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virStorageVolPtr vol = NULL;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(vol = <API key>(priv->conn, args->vol)))
goto cleanup;
if ((pool = <API key>(vol)) == NULL)
goto cleanup;
<API key>(&ret->pool, pool);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (vol)
virStorageVolFree(vol);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
int num;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = <API key>(priv->conn, args->pool)))
goto cleanup;
if ((num = <API key>(pool)) < 0)
goto cleanup;
ret->num = num;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = <API key>(priv->conn, args->pool)))
goto cleanup;
if (<API key>(pool, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = <API key>(priv->conn, args->pool)))
goto cleanup;
if (<API key>(pool, args->autostart) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = <API key>(priv->conn, args->pool)))
goto cleanup;
if (<API key>(pool) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (pool)
virStoragePoolFree(pool);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
virStorageVolPtr vol = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = <API key>(priv->conn, args->pool)))
goto cleanup;
if ((vol = <API key>(pool, args->xml, args->flags)) == NULL)
goto cleanup;
<API key>(&ret->vol, vol);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (pool)
virStoragePoolFree(pool);
if (vol)
virStorageVolFree(vol);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
virStorageVolPtr clonevol = NULL;
virStorageVolPtr vol = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = <API key>(priv->conn, args->pool)))
goto cleanup;
if (!(clonevol = <API key>(priv->conn, args->clonevol)))
goto cleanup;
if ((vol = <API key>(pool, args->xml, clonevol, args->flags)) == NULL)
goto cleanup;
<API key>(&ret->vol, vol);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (pool)
virStoragePoolFree(pool);
if (clonevol)
virStorageVolFree(clonevol);
if (vol)
virStorageVolFree(vol);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virStorageVolPtr vol = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(vol = <API key>(priv->conn, args->vol)))
goto cleanup;
if (virStorageVolDelete(vol, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (vol)
virStorageVolFree(vol);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virStorageVolPtr vol = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
virStreamPtr st = NULL;
<API key> stream = NULL;
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(vol = <API key>(priv->conn, args->vol)))
goto cleanup;
if (!(st = virStreamNew(priv->conn, VIR_STREAM_NONBLOCK)))
goto cleanup;
if (!(stream = <API key>(client, st, remoteProgram, &msg->header)))
goto cleanup;
if (<API key>(vol, st, args->offset, args->length, args->flags) < 0)
goto cleanup;
if (<API key>(client, stream, true) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0) {
<API key>(rerr);
if (stream) {
virStreamAbort(st);
<API key>(client, stream);
} else {
virStreamFree(st);
}
}
if (vol)
virStorageVolFree(vol);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virStorageVolPtr vol = NULL;
virStorageVolInfo tmp;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(vol = <API key>(priv->conn, args->vol)))
goto cleanup;
if (<API key>(vol, &tmp) < 0)
goto cleanup;
ret->type = tmp.type;
ret->capacity = tmp.capacity;
ret->allocation = tmp.allocation;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (vol)
virStorageVolFree(vol);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virStorageVolPtr vol = NULL;
char *name;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(vol = <API key>(priv->conn, args->vol)))
goto cleanup;
if ((name = <API key>(vol)) == NULL)
goto cleanup;
ret->name = name;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (vol)
virStorageVolFree(vol);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virStorageVolPtr vol = NULL;
char *xml;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(vol = <API key>(priv->conn, args->vol)))
goto cleanup;
if ((xml = <API key>(vol, args->flags)) == NULL)
goto cleanup;
ret->xml = xml;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (vol)
virStorageVolFree(vol);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virStorageVolPtr vol = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((vol = <API key>(priv->conn, args->key)) == NULL)
goto cleanup;
<API key>(&ret->vol, vol);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (vol)
virStorageVolFree(vol);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virStoragePoolPtr pool = NULL;
virStorageVolPtr vol = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(pool = <API key>(priv->conn, args->pool)))
goto cleanup;
if ((vol = <API key>(pool, args->name)) == NULL)
goto cleanup;
<API key>(&ret->vol, vol);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (pool)
virStoragePoolFree(pool);
if (vol)
virStorageVolFree(vol);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args,
<API key> *ret);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args, ret);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args,
<API key> *ret)
{
int rv = -1;
virStorageVolPtr vol = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if ((vol = <API key>(priv->conn, args->path)) == NULL)
goto cleanup;
<API key>(&ret->vol, vol);
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (vol)
virStorageVolFree(vol);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virStorageVolPtr vol = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(vol = <API key>(priv->conn, args->vol)))
goto cleanup;
if (virStorageVolResize(vol, args->capacity, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (vol)
virStorageVolFree(vol);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virStorageVolPtr vol = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
virStreamPtr st = NULL;
<API key> stream = NULL;
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(vol = <API key>(priv->conn, args->vol)))
goto cleanup;
if (!(st = virStreamNew(priv->conn, VIR_STREAM_NONBLOCK)))
goto cleanup;
if (!(stream = <API key>(client, st, remoteProgram, &msg->header)))
goto cleanup;
if (virStorageVolUpload(vol, st, args->offset, args->length, args->flags) < 0)
goto cleanup;
if (<API key>(client, stream, false) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0) {
<API key>(rerr);
if (stream) {
virStreamAbort(st);
<API key>(client, stream);
} else {
virStreamFree(st);
}
}
if (vol)
virStorageVolFree(vol);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virStorageVolPtr vol = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(vol = <API key>(priv->conn, args->vol)))
goto cleanup;
if (virStorageVolWipe(vol, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (vol)
virStorageVolFree(vol);
return rv;
}
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
<API key> *args);
static int <API key>(
virNetServerPtr server,
<API key> client,
virNetMessagePtr msg,
<API key> rerr,
void *args,
void *ret ATTRIBUTE_UNUSED)
{
VIR_DEBUG("server=%p client=%p msg=%p rerr=%p args=%p ret=%p", server, client, msg, rerr, args, ret);
return <API key>(server, client, msg, rerr, args);
}
static int <API key>(
virNetServerPtr server ATTRIBUTE_UNUSED,
<API key> client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
<API key> rerr,
<API key> *args)
{
int rv = -1;
virStorageVolPtr vol = NULL;
struct daemonClientPrivate *priv =
<API key>(client);
if (!priv->conn) {
virReportError(<API key>, "%s", _("connection not open"));
goto cleanup;
}
if (!(vol = <API key>(priv->conn, args->vol)))
goto cleanup;
if (<API key>(vol, args->algorithm, args->flags) < 0)
goto cleanup;
rv = 0;
cleanup:
if (rv < 0)
<API key>(rerr);
if (vol)
virStorageVolFree(vol);
return rv;
}
<API key> remoteProcs[] = {
{ /* Unused 0 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method ConnectOpen => 1 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method ConnectClose => 2 */
<API key>,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method ConnectGetType => 3 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method ConnectGetVersion => 4 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method ConnectGetMaxVcpus => 5 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method NodeGetInfo => 6 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 7 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method DomainAttachDevice => 8 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainCreate => 9 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainCreateXML => 10 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method DomainDefineXML => 11 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method DomainDestroy => 12 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method DomainDetachDevice => 13 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainGetXMLDesc => 14 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method DomainGetAutostart => 15 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method DomainGetInfo => 16 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method DomainGetMaxMemory => 17 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method DomainGetMaxVcpus => 18 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method DomainGetOSType => 19 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method DomainGetVcpus => 20 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 21 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method DomainLookupByID => 22 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method DomainLookupByName => 23 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method DomainLookupByUUID => 24 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 25 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method DomainPinVcpu => 26 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainReboot => 27 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainResume => 28 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainSetAutostart => 29 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method DomainSetMaxMemory => 30 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method DomainSetMemory => 31 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainSetVcpus => 32 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainShutdown => 33 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainSuspend => 34 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainUndefine => 35 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method <API key> => 36 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method ConnectListDomains => 37 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method ConnectListNetworks => 38 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method NetworkCreate => 39 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method NetworkCreateXML => 40 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method NetworkDefineXML => 41 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method NetworkDestroy => 42 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method NetworkGetXMLDesc => 43 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method NetworkGetAutostart => 44 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 45 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method NetworkLookupByName => 46 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method NetworkLookupByUUID => 47 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method NetworkSetAutostart => 48 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method NetworkUndefine => 49 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method <API key> => 50 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method ConnectNumOfDomains => 51 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 52 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method DomainCoreDump => 53 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainRestore => 54 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainSave => 55 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 56 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 57 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 58 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method ConnectGetHostname => 59 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 60 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 61 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 62 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainMigrateFinish => 63 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method DomainBlockStats => 64 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 65 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method AuthList => 66 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method AuthSaslInit => 67 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method AuthSaslStart => 68 */
<API key>,
sizeof(remote_<API key>),
(xdrproc_t)xdr_remote_<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method AuthSaslStep => 69 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method AuthPolkit => 70 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 71 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 72 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 73 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 74 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 75 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 76 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 77 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method StoragePoolCreate => 78 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method StoragePoolBuild => 79 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method StoragePoolDestroy => 80 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method StoragePoolDelete => 81 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method StoragePoolUndefine => 82 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method StoragePoolRefresh => 83 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 84 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 85 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 86 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method StoragePoolGetInfo => 87 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 88 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 89 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 90 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method <API key> => 91 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 92 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method StorageVolCreateXML => 93 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method StorageVolDelete => 94 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 95 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 96 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 97 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method StorageVolGetInfo => 98 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 99 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method StorageVolGetPath => 100 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 101 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method NodeGetFreeMemory => 102 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method DomainBlockPeek => 103 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method DomainMemoryPeek => 104 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 105 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 106 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Async event <API key> => 107 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 108 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 109 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method ConnectGetURI => 110 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method NodeNumOfDevices => 111 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method NodeListDevices => 112 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 113 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 114 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method NodeDeviceGetParent => 115 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method NodeDeviceNumOfCaps => 116 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method NodeDeviceListCaps => 117 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method NodeDeviceDettach => 118 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method NodeDeviceReAttach => 119 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method NodeDeviceReset => 120 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 121 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 122 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method NodeDeviceCreateXML => 123 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method NodeDeviceDestroy => 124 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method <API key> => 125 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 126 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 127 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 128 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 129 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method InterfaceGetXMLDesc => 130 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method InterfaceDefineXML => 131 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method InterfaceUndefine => 132 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method InterfaceCreate => 133 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method InterfaceDestroy => 134 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method <API key> => 135 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 136 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 137 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 138 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method ConnectNumOfSecrets => 139 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method ConnectListSecrets => 140 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method SecretLookupByUUID => 141 */
remoteDispatch<API key>,
sizeof(remote_<API key>),
(xdrproc_t)xdr_remote_<API key>,
sizeof(remote_<API key>),
(xdrproc_t)xdr_remote_<API key>,
true,
1
},
{ /* Method SecretDefineXML => 142 */
<API key>,
sizeof(remote_<API key>),
(xdrproc_t)xdr_remote_<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method SecretGetXMLDesc => 143 */
remoteDispatch<API key>,
sizeof(remote_<API key>),
(xdrproc_t)xdr_remote_<API key>,
sizeof(remote_<API key>),
(xdrproc_t)xdr_remote_<API key>,
true,
1
},
{ /* Method SecretSetValue => 144 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method SecretGetValue => 145 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method SecretUndefine => 146 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method SecretLookupByUsage => 147 */
remoteDispatch<API key>,
sizeof(remote_<API key>),
(xdrproc_t)xdr_remote_<API key>,
sizeof(remote_<API key>),
(xdrproc_t)xdr_remote_<API key>,
true,
1
},
{ /* Method <API key> => 148 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method ConnectIsSecure => 149 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method DomainIsActive => 150 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method DomainIsPersistent => 151 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method NetworkIsActive => 152 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method NetworkIsPersistent => 153 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method StoragePoolIsActive => 154 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 155 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method InterfaceIsActive => 156 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 157 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method ConnectCompareCPU => 158 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method DomainMemoryStats => 159 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 160 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 161 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method ConnectBaselineCPU => 162 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method DomainGetJobInfo => 163 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method DomainAbortJob => 164 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method StorageVolWipe => 165 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 166 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 167 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method <API key> => 168 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Async event DomainEventReboot => 169 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event <API key> => 170 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventWatchdog => 171 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventIoError => 172 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventGraphics => 173 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 174 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 175 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 176 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method NWFilterGetXMLDesc => 177 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 178 */
<API key>,
0,
(xdrproc_t)xdr_void,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 179 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method NWFilterDefineXML => 180 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method NWFilterUndefine => 181 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method DomainManagedSave => 182 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 183 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 184 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 185 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 186 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method DomainSnapshotNum => 187 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 188 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 189 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 190 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 191 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 192 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 193 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainGetBlockInfo => 194 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Async event <API key> => 195 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 196 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 197 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 198 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method DomainSetVcpusFlags => 199 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainGetVcpusFlags => 200 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method DomainOpenConsole => 201 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainIsUpdated => 202 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method ConnectGetSysinfo => 203 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 204 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 205 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 206 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 207 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method StorageVolUpload => 208 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method StorageVolDownload => 209 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainInjectNMI => 210 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainScreenshot => 211 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method DomainGetState => 212 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method DomainMigrateBegin3 => 213 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 214 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 215 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 216 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 217 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 218 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 219 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 220 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 221 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 222 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 223 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Async event <API key> => 224 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainPinVcpuFlags => 225 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainSendKey => 226 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method NodeGetCPUStats => 227 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method NodeGetMemoryStats => 228 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 229 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 230 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method DomainUndefineFlags => 231 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method DomainSaveFlags => 232 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainRestoreFlags => 233 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainDestroyFlags => 234 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method <API key> => 235 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 236 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Method DomainBlockJobAbort => 237 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 238 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 239 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainBlockPull => 240 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventBlockJob => 241 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 242 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 243 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 244 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method DomainReset => 245 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 246 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 247 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Async event <API key> => 248 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainOpenGraphics => 249 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 250 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainBlockResize => 251 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 252 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 253 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 254 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 255 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 256 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 257 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method DomainShutdownFlags => 258 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 259 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method StorageVolResize => 260 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 261 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainGetCPUStats => 262 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method DomainGetDiskErrors => 263 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method DomainSetMetadata => 264 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainGetMetadata => 265 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method DomainBlockRebase => 266 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainPMWakeup => 267 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event <API key> => 268 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event DomainEventPMwakeup => 269 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event <API key> => 270 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 271 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 272 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 273 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 274 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 275 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Async event <API key> => 276 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainGetHostname => 277 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 278 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method DomainPinEmulator => 279 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 280 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 281 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 282 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 283 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 284 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 285 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 286 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 287 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 288 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 289 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method DomainBlockCommit => 290 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method NetworkUpdate => 291 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Async event <API key> => 292 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method NodeGetCPUMap => 293 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method DomainFSTrim => 294 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 295 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method DomainOpenChannel => 296 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 297 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method DomainGetJobStats => 298 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 299 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 300 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 301 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 302 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 303 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 304 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 305 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 306 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 307 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 308 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 309 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 310 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Async event <API key> => 311 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 312 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
0
},
{ /* Method <API key> => 313 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 314 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Async event <API key> => 315 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 316 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
true,
1
},
{ /* Method <API key> => 317 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
1
},
{ /* Async event <API key> => 318 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event <API key> => 319 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event <API key> => 320 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event <API key> => 321 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event <API key> => 322 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event <API key> => 323 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event <API key> => 324 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event <API key> => 325 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event <API key> => 326 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event <API key> => 327 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event <API key> => 328 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event <API key> => 329 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event <API key> => 330 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event <API key> => 331 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event <API key> => 332 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Async event <API key> => 333 */
NULL,
0,
(xdrproc_t)xdr_void,
0,
(xdrproc_t)xdr_void,
true,
0
},
{ /* Method <API key> => 334 */
<API key>,
sizeof(<API key>),
(xdrproc_t)<API key>,
0,
(xdrproc_t)xdr_void,
true,
0
},
};
size_t remoteNProcs = ARRAY_CARDINALITY(remoteProcs);
|
<?php
namespace Bookly\Backend;
use Bookly\Backend\Modules;
use Bookly\Frontend;
use Bookly\Lib;
/**
* Class Backend
* @package Bookly\Backend
*/
class Backend
{
public function __construct()
{
// Backend controllers.
$this->apearanceController = Modules\Appearance\Controller::getInstance();
$this->calendarController = Modules\Calendar\Controller::getInstance();
$this->customerController = Modules\Customers\Controller::getInstance();
$this-><API key> = Modules\Notifications\Controller::getInstance();
$this->paymentController = Modules\Payments\Controller::getInstance();
$this->serviceController = Modules\Services\Controller::getInstance();
$this->smsController = Modules\Sms\Controller::getInstance();
$this->settingsController = Modules\Settings\Controller::getInstance();
$this->staffController = Modules\Staff\Controller::getInstance();
$this->couponsController = Modules\Coupons\Controller::getInstance();
$this-><API key> = Modules\CustomFields\Controller::getInstance();
$this-><API key> = Modules\Appointments\Controller::getInstance();
$this->debugController = Modules\Debug\Controller::getInstance();
// Frontend controllers that work via admin-ajax.php.
$this->bookingController = Frontend\Modules\Booking\Controller::getInstance();
$this-><API key> = Frontend\Modules\CustomerProfile\Controller::getInstance();
if ( ! Lib\Config::isPaymentDisabled( Lib\Entities\Payment::TYPE_AUTHORIZENET ) ) {
$this-><API key> = Frontend\Modules\AuthorizeNet\Controller::getInstance();
}
if ( ! Lib\Config::isPaymentDisabled( Lib\Entities\Payment::TYPE_PAYULATAM ) ) {
$this->payulatamController = Frontend\Modules\PayuLatam\Controller::getInstance();
}
if ( ! Lib\Config::isPaymentDisabled( Lib\Entities\Payment::TYPE_STRIPE ) ) {
$this->stripeController = Frontend\Modules\Stripe\Controller::getInstance();
}
$this-><API key> = Frontend\Modules\WooCommerce\Controller::getInstance();
add_action( 'admin_menu', array( $this, 'addAdminMenu' ) );
add_action( 'wp_loaded', array( $this, 'init' ) );
add_action( 'admin_init', array( $this, 'addTinyMCEPlugin' ) );
}
public function init()
{
if ( ! session_id() ) {
@session_start();
}
}
public function addTinyMCEPlugin()
{
new Modules\TinyMce\Plugin();
}
public function addAdminMenu()
{
/** @var \WP_User $current_user */
global $current_user;
// Translated submenu pages.
$calendar = __( 'Calendar', 'bookly' );
$appointments = __( 'Appointments', 'bookly' );
$staff_members = __( 'Staff Members', 'bookly' );
$services = __( 'Services', 'bookly' );
$sms = __( 'SMS Notifications', 'bookly' );
$notifications = __( 'Email Notifications', 'bookly' );
$customers = __( 'Customers', 'bookly' );
$payments = __( 'Payments', 'bookly' );
$appearance = __( 'Appearance', 'bookly' );
$settings = __( 'Settings', 'bookly' );
$coupons = __( 'Coupons', 'bookly' );
$custom_fields = __( 'Custom Fields', 'bookly' );
if ( $current_user->has_cap( 'administrator' ) || Lib\Entities\Staff::query()->where( 'wp_user_id', $current_user->ID )->count() ) {
if ( function_exists( 'add_options_page' ) ) {
$dynamic_position = '80.0000001' . mt_rand( 1, 1000 ); // position always is under `Settings`
add_menu_page( 'Bookly', 'Bookly', 'read', 'ab-system', '',
plugins_url( 'resources/images/menu.png', __FILE__ ), $dynamic_position );
add_submenu_page( 'ab-system', $calendar, $calendar, 'read', 'ab-calendar',
array( $this->calendarController, 'index' ) );
add_submenu_page( 'ab-system', $appointments, $appointments, 'manage_options', 'ab-appointments',
array( $this-><API key>, 'index' ) );
do_action( '<API key>' );
if ( $current_user->has_cap( 'administrator' ) ) {
add_submenu_page( 'ab-system', $staff_members, $staff_members, 'manage_options', Modules\Staff\Controller::page_slug,
array( $this->staffController, 'index' ) );
} else {
if ( get_option( '<API key>' ) == 1 ) {
add_submenu_page( 'ab-system', __( 'Profile', 'bookly' ), __( 'Profile', 'bookly' ), 'read', Modules\Staff\Controller::page_slug,
array( $this->staffController, 'index' ) );
}
}
add_submenu_page( 'ab-system', $services, $services, 'manage_options', Modules\Services\Controller::page_slug,
array( $this->serviceController, 'index' ) );
add_submenu_page( 'ab-system', $customers, $customers, 'manage_options', Modules\Customers\Controller::page_slug,
array( $this->customerController, 'index' ) );
add_submenu_page( 'ab-system', $notifications, $notifications, 'manage_options', 'ab-notifications',
array( $this-><API key>, 'index' ) );
add_submenu_page( 'ab-system', $sms, $sms, 'manage_options', Modules\Sms\Controller::page_slug,
array( $this->smsController, 'index' ) );
add_submenu_page( 'ab-system', $payments, $payments, 'manage_options', 'ab-payments',
array( $this->paymentController, 'index' ) );
add_submenu_page( 'ab-system', $appearance, $appearance, 'manage_options', 'ab-appearance',
array( $this->apearanceController, 'index' ) );
add_submenu_page( 'ab-system', $custom_fields, $custom_fields, 'manage_options', 'ab-custom-fields',
array( $this-><API key>, 'index' ) );
add_submenu_page( 'ab-system', $coupons, $coupons, 'manage_options', 'ab-coupons',
array( $this->couponsController, 'index' ) );
add_submenu_page( 'ab-system', $settings, $settings, 'manage_options', Modules\Settings\Controller::page_slug,
array( $this->settingsController, 'index' ) );
if ( isset ( $_GET['page'] ) && $_GET['page'] == 'ab-debug' ) {
add_submenu_page( 'ab-system', 'Debug', 'Debug', 'manage_options', 'ab-debug',
array( $this->debugController, 'index' ) );
}
global $submenu;
do_action( 'bookly_admin_menu', 'ab-system' );
unset ( $submenu['ab-system'][0] );
}
}
}
}
|
## See "(5/13/10)" for a temporary fix.
# Sep 2014. Wrote new update_diversions().
# New standard names and BMI updates and testing.
# Nov 2013. Converted TopoFlow to a Python package.
# Feb 2013. Adapted to use EMELI framework.
# Jan 2013. Shared scalar doubles are now 0D numpy arrays.
# This makes them mutable and allows components with
# a reference to them to see them change.
# So far: Q_outlet, Q_peak, Q_min...
# Jan 2013. Revised handling of input/output names.
# Oct 2012. CSDMS Standard Names and BMI.
# May 2012. Shared scalar doubles are now 1-element 1D numpy arrays.
# This makes them mutable and allows components with
# a reference to them to see them change.
# So far: Q_outlet, Q_peak, Q_min...
# May 2010. Changes to initialize() and read_cfg_file()
# Mar 2010. Changed codes to code, widths to width,
# angles to angle, nvals to nval, z0vals to z0val,
# slopes to slope (for GUI tools and consistency
# across all process components)
# Aug 2009. Updates.
# Jul 2009. Updates.
# May 2009. Updates.
# Jan 2009. Converted from IDL.
# NB! In the CFG file, change MANNING and LAW_OF_WALL flags to
# Notes: Set self.u in manning and law_of_wall functions ??
# Update friction factor in manning() and law_of_wall() ?
# Double check how Rh is used in law_of_the_wall().
# d8_flow has "flow_grids", but this one has "codes".
# Make sure values are not stored twice.
# NOTES: This file defines a "base class" for channelized flow
# components as well as functions used by most or
# all channel flow methods. The methods of this class
# (especially "update_velocity") should be over-ridden as
# necessary for different methods of modeling channelized
# flow. See <API key>.py,
# <API key>.py and <API key>.py.
# NOTES: <API key>() is called by the
# update_velocity() methods of <API key>.py
# and <API key>.py.
# class channels_component
# ## get_attribute() # (defined in each channel component)
# get_input_var_names() # (5/15/12)
# <API key>() # (5/15/12)
# get_var_name() # (5/15/12)
# get_var_units() # (5/15/12)
# set_constants()
# initialize()
# update()
# finalize()
# <API key>() # (5/11/10)
# <API key>()
# <API key>() # (9/22/14)
# <API key>()
# <API key>()
# <API key>() # (2/3/13)
# update_R()
# update_R_integral()
# update_discharge()
# update_diversions() # (9/22/14)
# update_flow_volume()
# update_flow_depth()
# <API key>()
# update_shear_stress() # (9/9/14, depth-slope product)
# update_shear_speed() # (9/9/14)
# update_trapezoid_Rh()
# <API key>() # (9/9/14)
# update_velocity() # (override as needed)
# <API key>()
# <API key>() # (9/9/14)
# <API key>()
# update_peak_values() # (at the main outlet)
# <API key>() # (moved here from basins.py)
# <API key>() # (don't add into update())
# check_flow_depth()
# check_flow_velocity()
# open_input_files()
# read_input_files()
# close_input_files()
# <API key>()
# bundle_output_files() # (9/21/14. Not used yet)
# open_output_files()
# write_output_files()
# close_output_files()
# save_grids()
# save_pixel_values()
# manning_formula()
# law_of_the_wall()
# print_status_report()
# remove_bad_slopes()
# Functions: # (stand-alone versions of these)
# Trapezoid_Rh()
# Manning_Formula()
# Law_of_the_Wall()
import numpy as np
import os, os.path
from topoflow.utils import BMI_base
# from topoflow.utils import d8_base
from topoflow.utils import file_utils
from topoflow.utils import model_input
from topoflow.utils import model_output
from topoflow.utils import ncgs_files
from topoflow.utils import ncts_files
from topoflow.utils import rtg_files
from topoflow.utils import text_ts_files
from topoflow.utils import tf_d8_base as d8_base
from topoflow.utils import tf_utils
class channels_component( BMI_base.BMI_component ):
# Note: <API key> *must* be liquid-only precip.
_input_var_names = [
'<API key>', # (P_rain)
'<API key>',
## '<API key>',
## 'land_surface__slope',
'<API key>',
'<API key>',
'<API key>',
'<API key>',
'<API key>' ] # (rho_H2O)
# 'canals__count', # n_canals
# '<API key>', # canals_in_x
# '<API key>', # canals_in_y
# '<API key>', # Q_canals_fraction
# '<API key>', # canals_out_x
# '<API key>', # canals_out_y
# '<API key>', # Q_canals_out
# 'sinks__count', # n_sinks
# 'sinks__x_coordinate', # sinks_x
# 'sinks__y_coordinate', # sinks_y
# '<API key>', # Q_sinks
# 'sources__count', # n_sources
# '<API key>', # sources_x
# '<API key>', # sources_y
# '<API key>' ] # Q_sources
# Maybe add these out_vars later.
# ['time_sec', 'time_min' ]
_output_var_names = [
'<API key>', # f_outlet
'<API key>', # d_outlet
'<API key>', # Td_peak
'<API key>', # T_peak
'<API key>', # Tu_peak
'<API key>', # vol_Q
'<API key>', # d_peak
'<API key>', # Q_peak
'<API key>', # u_peak
'<API key>', # Q_outlet
'<API key>', # u_outlet
'<API key>', # Q_canals_in
'<API key>', # S_bed
'<API key>', # z0val_max
'<API key>', # z0val_min
'<API key>', # z0val
'<API key>', # tau
'<API key>', # u_star
'<API key>', # sinu
'<API key>', # vol
'<API key>', # froude
'<API key>',
'<API key>', # nval_max
'<API key>', # nval_min
'<API key>', # nval
'<API key>', # S_free
# These might only be available at the end of run.
'<API key>', # d_max
'<API key>', # d_min
'<API key>', # Q_max
'<API key>', # Q_min
'<API key>', # u_max
'<API key>', # u_min
'<API key>',
'<API key>',
'<API key>',
'<API key>',
'<API key>',
'<API key>', # A_wet
'<API key>', # P_wet
## '<API key>', # (not used)
'<API key>', # width
'<API key>', # angle
'<API key>',
'<API key>', # vol_R
'model__time_step',
'<API key>' ]
_var_name_map = {
'<API key>': 'P_rain',
'<API key>': 'MR',
## '<API key>': 'DEM',
## 'land_surface__slope': 'S_bed',
'<API key>': 'GW',
'<API key>': 'ET',
'<API key>': 'IN',
'<API key>': 'SM',
'<API key>': 'rho_H2O',
'<API key>':'f_outlet',
'<API key>': 'd_outlet',
'<API key>': 'Td_peak',
'<API key>': 'T_peak',
'<API key>': 'Tu_peak',
'<API key>': 'Q_outlet',
'<API key>': 'u_outlet',
'<API key>': 'vol_Q',
'<API key>': 'd_peak',
'<API key>':'Q_peak',
'<API key>': 'u_peak',
'<API key>': 'Q_canals_in',
'<API key>': 'S_bed',
'<API key>': 'z0val_max',
'<API key>': 'z0val_min',
'<API key>': 'z0val',
'<API key>': 'tau',
'<API key>': 'u_star',
'<API key>': 'sinu',
'<API key>': 'vol',
'<API key>': 'nval_max',
'<API key>': 'nval_min',
'<API key>': 'froude',
'<API key>': 'f',
'<API key>': 'nval',
'<API key>': 'S_free',
'<API key>': 'd_max',
'<API key>': 'd_min',
'<API key>': 'Q_max',
'<API key>': 'Q_min',
'<API key>': 'u_max',
'<API key>': 'u_min',
'<API key>': 'Rh',
'<API key>': 'd0',
'<API key>': 'd',
'<API key>': 'Q',
'<API key>': 'u',
'<API key>': 'A_wet',
'<API key>': 'P_wet',
## '<API key>': # (not used)
'<API key>': 'width',
'<API key>': 'angle',
'<API key>': 'vol_R',
'<API key>': 'R',
'model__time_step': 'dt',
'<API key>': 'da',
'canals__count': 'n_canals',
'<API key>': 'canals_in_x',
'<API key>': 'canals_in_y',
'<API key>': 'Q_canals_fraction',
'<API key>': 'canals_out_x',
'<API key>': 'canals_out_y',
'<API key>': 'Q_canals_out',
'sinks__count': 'n_sinks',
'sinks__x_coordinate': 'sinks_x',
'sinks__y_coordinate': 'sinks_y',
'<API key>': 'Q_sinks',
'sources__count': 'n_sources',
'<API key>': 'sources_x',
'<API key>': 'sources_y',
'<API key>': 'Q_sources' }
# Create an "inverse var name map"
# inv_map = dict(zip(map.values(), map.keys()))
## _long_name_map = dict( zip(_var_name_map.values(),
## _var_name_map.keys() ) )
_var_units_map = {
'<API key>': 'm s-1',
'<API key>': 'm s-1',
## '<API key>': 'm',
## 'land_surface__slope': '1',
'<API key>': 'm s-1',
'<API key>': 'm s-1',
'<API key>': 'm s-1',
'<API key>': 'm s-1',
'<API key>': 'kg m-3',
'<API key>': '1',
'<API key>': 'm',
'<API key>': 'min',
'<API key>': 'min',
'<API key>': 'min',
'<API key>': 'm3',
'<API key>': 'm',
'<API key>': 'm3 s-1',
'<API key>': 'm s-1',
'<API key>': 'm3',
'<API key>': 'm s-1',
'<API key>': 'm3 s-1',
'<API key>': '1',
'<API key>': 'm',
'<API key>': 'm',
'<API key>': 'm',
'<API key>': 'kg m-1 s-2',
'<API key>': 'm s-1',
'<API key>': '1',
'<API key>': 'm3',
'<API key>': '1',
'<API key>': '1',
'<API key>': 'm-1/3 s',
'<API key>': 'm-1/3 s',
'<API key>': 'm-1/3 s',
'<API key>': '1',
'<API key>': 'm',
'<API key>': 'm',
'<API key>': 'm3 s-1',
'<API key>': 'm3 s-1',
'<API key>': 'm s-1',
'<API key>': 'm s-1',
'<API key>': 'm',
'<API key>': 'm',
'<API key>': 'm',
'<API key>': 'm3 s-1',
'<API key>': 'm s-1',
'<API key>': 'm2',
'<API key>': 'm',
'<API key>': 'm',
'<API key>': 'rad', # CHECKED
'<API key>': 'm3',
'<API key>': 'm s-1',
'model__time_step': 's',
'<API key>': 'm2',
'canals__count': '1',
'<API key>': 'm',
'<API key>': 'm',
'<API key>': '1',
'<API key>': 'm',
'<API key>': 'm',
'<API key>': 'm3 s-1',
'sinks__count': '1',
'sinks__x_coordinate': 'm',
'sinks__y_coordinate': 'm',
'<API key>': 'm3 s-1',
'sources__count': '1',
'<API key>': 'm',
'<API key>': 'm',
'<API key>': 'm3 s-1' }
# Return NumPy string arrays vs. Python lists ?
## _input_var_names = np.array( _input_var_names )
## _output_var_names = np.array( _output_var_names )
def get_input_var_names(self):
# Note: These are currently variables needed from other
# components vs. those read from files or GUI.
return self._input_var_names
# get_input_var_names()
def <API key>(self):
return self._output_var_names
# <API key>()
def get_var_name(self, long_var_name):
return self._var_name_map[ long_var_name ]
# get_var_name()
def get_var_units(self, long_var_name):
return self._var_units_map[ long_var_name ]
# get_var_units()
## def get_var_type(self, long_var_name):
## # So far, all vars have type "double",
## # but use the one in BMI_base instead.
## return 'float64'
## # get_var_type()
def set_constants(self):
# Define some constants
self.g = np.float64(9.81) # (gravitation const.)
self.aval = np.float64(0.476) # (integration const.)
self.kappa = np.float64(0.408) # (von Karman's const.)
self.law_const = np.sqrt(self.g) / self.kappa
self.one_third = np.float64(1.0) / 3.0
self.two_thirds = np.float64(2.0) / 3.0
self.deg_to_rad = np.pi / 180.0
# set_constants()
def initialize(self, cfg_file=None, mode="nondriver", SILENT=False):
if not(SILENT):
print ' '
print 'Channels component: Initializing...'
self.status = 'initializing' # (OpenMI 2.0 convention)
self.mode = mode
self.cfg_file = cfg_file
# Load component parameters from a config file
self.set_constants() # (12/7/09)
# print 'CHANNELS calling <API key>()...'
self.<API key>()
# print 'CHANNELS calling read_grid_info()...'
self.read_grid_info()
#print 'CHANNELS calling <API key>()...'
self.<API key>() # (5/14/10)
# This must come before "Disabled" test.
# print 'CHANNELS calling <API key>()...'
self.<API key>()
# Has component been turned off ?
if (self.comp_status == 'Disabled'):
if not(SILENT):
print 'Channels component: Disabled.'
self.SAVE_Q_GRIDS = False # (It is True by default.)
self.SAVE_Q_PIXELS = False # (It is True by default.)
self.DONE = True
self.status = 'initialized' # (OpenMI 2.0 convention)
return
## print 'min(d0), max(d0) =', self.d0.min(), self.d0.max()
# Open input files needed to initialize vars
# Can't move read_input_files() to start of
# update(), since initial values needed here.
# print 'CHANNELS calling open_input_files()...'
self.open_input_files()
print 'CHANNELS calling read_input_files()...'
self.read_input_files()
# Initialize variables
print 'CHANNELS calling initialize_d8_vars()...'
self.initialize_d8_vars() # (depend on D8 flow grid)
print 'CHANNELS calling <API key>()...'
self.<API key>()
# (5/12/10) I think this is obsolete now.
# Make sure self.Q_ts_file is not NULL (12/22/05)
# This is only output file that is set by default
# and is still NULL if user hasn't opened the
# output var dialog for the channel process.
## if (self.SAVE_Q_PIXELS and (self.Q_ts_file == '')):
## self.Q_ts_file = (self.case_prefix + '_0D-Q.txt')
self.open_output_files()
self.status = 'initialized' # (OpenMI 2.0 convention)
# initialize()
## def update(self, dt=-1.0, time_seconds=None):
def update(self, dt=-1.0):
# Note that u and d from previous time step
# must be used on RHS of the equations here.
self.status = 'updating' # (OpenMI 2.0 convention)
# There may be times where we want to call this method
# even if component is not the driver. But note that
# the TopoFlow driver also makes this same call.
if (self.mode == 'driver'):
self.<API key>(self.Q_outlet, 'Q_out', '[m^3/s]')
interval=0.5) # [seconds]
# For testing (5/19/12)
# self.<API key>(self.Q_outlet, 'Q_out', '[m^3/s] CHANNEL')
## DEBUG = True
DEBUG = False
# Update computed values
if (DEBUG): print '
self.update_R()
if (DEBUG): print '
self.update_R_integral()
if (DEBUG): print '
self.update_discharge()
if (DEBUG): print '
self.update_diversions()
if (DEBUG): print '
self.update_flow_volume()
if (DEBUG): print '
self.update_flow_depth()
if not(self.DYNAMIC_WAVE):
if (DEBUG): print '
self.update_trapezoid_Rh()
# print 'Rhmin, Rhmax =', self.Rh.min(), self.Rh.max()a
# (9/9/14) Moved this here from update_velocity() methods.
if not(self.KINEMATIC_WAVE):
if (DEBUG): print '
self.<API key>()
if (DEBUG): print '
self.update_shear_stress()
if (DEBUG): print '
self.update_shear_speed()
# Must update friction factor before velocity for DYNAMIC_WAVE.
if (DEBUG): print '
self.<API key>()
if (DEBUG): print '
self.update_velocity()
self.<API key>() # (set to zero)
if (DEBUG): print '
self.<API key>()
## print 'Rmin, Rmax =', self.R.min(), self.R.max()
## print 'Qmin, Qmax =', self.Q.min(), self.Q.max()
## print 'umin, umax =', self.u.min(), self.u.max()
## print 'dmin, dmax =', self.d.min(), self.d.max()
## print 'nmin, nmax =', self.nval.min(), self.nval.max()
## print 'Rhmin, Rhmax =', self.Rh.min(), self.Rh.max()
## print 'Smin, Smax =', self.S_bed.min(), self.S_bed.max()
if (DEBUG): print '
self.<API key>()
if (DEBUG): print '
self.update_peak_values()
if (DEBUG): print '
self.<API key>()
# This takes extra time and is now done
# only at the end, in finalize(). (8/19/13)
# But then "topoflow_driver" doesn't get
# correctly updated values for some reason.
## self.<API key>()
# Check computed values
D_OK = self.check_flow_depth()
U_OK = self.check_flow_velocity()
OK = (D_OK and U_OK)
# Read from files as needed to update vars
# NB! This is currently not needed for the "channel
# process" because values don't change over time and
# read_input_files() is called by initialize().
# if (self.time_index > 0):
# self.read_input_files()
# Write user-specified data to output files ?
# Components use own self.time_sec by default.
if (DEBUG): print '
self.write_output_files()
## self.write_output_files( time_seconds )
# Update internal clock
# after write_output_files()
if (DEBUG): print '
self.update_time( dt )
if (OK):
self.status = 'updated' # (OpenMI 2.0 convention)
else:
self.status = 'failed'
self.DONE = True
# update()
def finalize(self):
# We can compute mins and maxes in the final grids
# here, but the framework will not then pass them
# to any component (e.g. topoflow_driver) that may
# need them.
REPORT = True
self.<API key>( REPORT=REPORT ) ## (2/6/13)
self.print_final_report(comp_name='Channels component')
self.status = 'finalizing' # (OpenMI)
self.close_input_files() # TopoFlow input "data streams"
self.close_output_files()
self.status = 'finalized' # (OpenMI)
# Release all of the ports
# Make this call in "finalize()" method
# of the component's CCA Imple file
# self.release_cca_ports( d_services )
# finalize()
def <API key>(self):
# Note: The initialize() method calls <API key>()
# (in BMI_base.py), which calls this method at the end.
cfg_extension = self.get_attribute( 'cfg_extension' ).lower()
# cfg_extension = self.get_cfg_extension().lower()
self.KINEMATIC_WAVE = ("kinematic" in cfg_extension)
self.DIFFUSIVE_WAVE = ("diffusive" in cfg_extension)
self.DYNAMIC_WAVE = ("dynamic" in cfg_extension)
# (5/17/12) If MANNING, we need to set z0vals to -1 so
# they are always defined for use with new framework.
if (self.MANNING):
if (self.nval != None):
self.nval = np.float64( self.nval )
self.nval_min = self.nval.min()
self.nval_max = self.nval.max()
self.z0val = np.float64(-1)
self.z0val_min = np.float64(-1)
self.z0val_max = np.float64(-1)
if (self.LAW_OF_WALL):
if (self.z0val != None):
self.z0val = np.float64( self.z0val )
self.z0val_min = self.z0val.min()
self.z0val_max = self.z0val.max()
self.nval = np.float64(-1)
self.nval_min = np.float64(-1)
self.nval_max = np.float64(-1)
# These currently can't be set to anything
# else in the GUI, but need to be defined.
self.code_type = 'Grid'
self.slope_type = 'Grid'
# Make sure that all "save_dts" are larger or equal to
# the specified process dt. There is no point in saving
# results more often than they change.
# Issue a message to this effect if any are smaller ??
self.save_grid_dt = np.maximum(self.save_grid_dt, self.dt)
self.save_pixels_dt = np.maximum(self.save_pixels_dt, self.dt)
# This is now done in CSDMS_base.read_config_gui()
# for any var_name that starts with "SAVE_".
# self.SAVE_Q_GRID = (self.SAVE_Q_GRID == 'Yes')
# <API key>()
def initialize_d8_vars(self):
# Compute and store a variety of (static) D8
# flow grid variables. Embed structure into
# the "channel_base" component.
self.d8 = d8_base.d8_component()
# (5/13/10) Do next line here for now, until
# the d8 cfg_file includes static prefix.
# Same is done in GW_base.py.
# tf_d8_base.read_grid_info() also needs
# in_directory to be set. (10/27/11)
# D8 component builds its cfg filename from these
self.d8.site_prefix = self.site_prefix
self.d8.in_directory = self.in_directory
self.d8.initialize( cfg_file=None,
SILENT=self.SILENT,
REPORT=self.REPORT )
## self.code = self.d8.code # Don't need this.
# We'll need this once we shift from using
# "tf_d8_base.py" to the new "d8_base.py"
# self.d8.update(self.time, SILENT=False, REPORT=True)
# initialize_d8_vars()
def <API key>(self):
# Convert bank angles from degrees to radians.
self.angle = self.angle * self.deg_to_rad # [radians]
# 8/29/05. Multiply ds by (unitless) sinuosity
# Orig. ds is used by subsurface flow
# NB! We should also divide slopes in S_bed by
# the sinuosity, as now done here.
# NB! This saves a modified version of ds that
# is only used within the "channels" component.
# The original "ds" is stored within the
# topoflow model component and is used for
# subsurface flow, etc.
self.d8.ds_chan = (self.sinu * ds)
self.ds = (self.sinu * self.d8.ds)
self.d8.ds = (self.sinu * self.d8.ds) ### USE LESS MEMORY
S_bed = (S_bed / self.sinu)
self.slope = (self.slope / self.sinu)
self.S_bed = self.slope
# Initialize spatial grids
# NB! It is not a good idea to initialize the
# water depth grid to a nonzero scalar value.
print 'Initializing u, f, d grids...'
self.u = np.zeros([self.ny, self.nx], dtype='Float64')
self.f = np.zeros([self.ny, self.nx], dtype='Float64')
self.d = np.zeros([self.ny, self.nx], dtype='Float64') + self.d0
# Add this on (2/3/13) so make the TF driver happy
# during its initialize when it gets reference to R.
# But in "update_R()", be careful not to break the ref.
# "Q" may be subject to the same issue.
self.Q = np.zeros([self.ny, self.nx], dtype='Float64')
self.R = np.zeros([self.ny, self.nx], dtype='Float64')
# Initialize new grids. Is this needed? (9/13/14)
self.tau = np.zeros([self.ny, self.nx], dtype='Float64')
self.u_star = np.zeros([self.ny, self.nx], dtype='Float64')
self.froude = np.zeros([self.ny, self.nx], dtype='Float64')
# These are used to check mass balance
self.vol_R = self.initialize_scalar( 0, dtype='float64')
self.vol_Q = self.initialize_scalar( 0, dtype='float64')
# Make sure all slopes are valid & nonzero
# since otherwise flow will accumulate
if (self.KINEMATIC_WAVE):
self.remove_bad_slopes() #(3/8/07. Only Kin Wave case)
# Initial volume of water in each pixel
# Note: angles were read as degrees & converted to radians
L2 = self.d * np.tan(self.angle)
self.A_wet = self.d * (self.width + L2)
self.P_wet = self.width + (np.float64(2) * self.d / np.cos(self.angle) )
self.vol = self.A_wet * self.d8.ds
# Note: depth is often zero at the start of a run, and
# both width and then P_wet are also zero in places.
# Therefore initialize Rh as shown.
self.Rh = np.zeros([self.ny, self.nx], dtype='Float64')
## self.Rh = self.A_wet / self.P_wet # [m]
## print 'P_wet.min() =', self.P_wet.min()
## print 'width.min() =', self.width.min()
## self.<API key>() # (9/22/14)
self.<API key>()
self.<API key>()
self.<API key>() ## (2/3/13)
# Maybe save all refs in a dictionary
# called "self_values" here ? (2/19/13)
# Use a "reverse" var_name mapping?
# inv_map = dict(zip(map.values(), map.keys()))
## w = np.where( self.width <= 0 )
## nw = np.size( w[0] ) # (This is correct for 1D or 2D.)
## if (nw > 0):
## print 'WARNING:'
## print 'Number of locations where width==0 =', nw
## if (nw < 10):
## print 'locations =', w
## print ' '
# <API key>()
def <API key>(self):
# Compute source IDs from xy coordinates
source_rows = np.int32( self.sources_y / self.ny )
source_cols = np.int32( self.sources_x / self.nx )
self.source_IDs = (source_rows, source_cols)
## self.source_IDs = (source_rows * self.nx) + source_cols
# Compute sink IDs from xy coordinates
sink_rows = np.int32( self.sinks_y / self.ny )
sink_cols = np.int32( self.sinks_x / self.nx )
self.sink_IDs = (sink_rows, sink_cols)
## self.sink_IDs = (sink_rows * self.nx) + sink_cols
# Compute canal entrance IDs from xy coordinates
canal_in_rows = np.int32( self.canals_in_y / self.ny )
canal_in_cols = np.int32( self.canals_in_x / self.nx )
self.canal_in_IDs = (canal_in_rows, canal_in_cols)
## self.canal_in_IDs = (canal_in_rows * self.nx) + canal_in_cols
# Compute canal exit IDs from xy coordinates
canal_out_rows = np.int32( self.canals_out_y / self.ny )
canal_out_cols = np.int32( self.canals_out_x / self.nx )
self.canal_out_IDs = (canal_out_rows, canal_out_cols)
## self.canal_out_IDs = (canal_out_rows * self.nx) + canal_out_cols
# This will be computed from Q_canal_fraction and
# self.Q and then passed back to Diversions
self.Q_canals_in = np.array( self.n_sources, dtype='float64' )
# <API key>()
def <API key>(self):
# Note: These are retrieved and used by TopoFlow
# for the stopping condition. TopoFlow
# receives a reference to these, but in
# order to see the values change they need
# to be stored as mutable, 1D numpy arrays.
# Note: Q_last is internal to TopoFlow.
# self.Q_outlet = self.Q[ self.outlet_ID ]
self.Q_outlet = self.initialize_scalar(0, dtype='float64')
self.u_outlet = self.initialize_scalar(0, dtype='float64')
self.d_outlet = self.initialize_scalar(0, dtype='float64')
self.f_outlet = self.initialize_scalar(0, dtype='float64')
# <API key>()
def <API key>(self):
# Initialize peak values
self.Q_peak = self.initialize_scalar(0, dtype='float64')
self.T_peak = self.initialize_scalar(0, dtype='float64')
self.u_peak = self.initialize_scalar(0, dtype='float64')
self.Tu_peak = self.initialize_scalar(0, dtype='float64')
self.d_peak = self.initialize_scalar(0, dtype='float64')
self.Td_peak = self.initialize_scalar(0, dtype='float64')
# <API key>()
def <API key>(self):
# Initialize min & max values
# (2/3/13), for new framework.
v = 1e6
self.Q_min = self.initialize_scalar(v, dtype='float64')
self.Q_max = self.initialize_scalar(-v, dtype='float64')
self.u_min = self.initialize_scalar(v, dtype='float64')
self.u_max = self.initialize_scalar(-v, dtype='float64')
self.d_min = self.initialize_scalar(v, dtype='float64')
self.d_max = self.initialize_scalar(-v, dtype='float64')
# <API key>()
# def <API key>(self):
def update_R(self):
# Compute the "excess rainrate", R.
# Each term must have same units: [m/s]
# Sum = net gain/loss rate over pixel.
# R can be positive or negative. If negative, then
# water is removed from the surface at rate R until
# surface water is consumed.
# P = precip_rate [m/s] (converted by read_input_data()).
# SM = snowmelt rate [m/s]
# GW = seep rate [m/s] (water_table intersects surface)
# ET = evap rate [m/s]
# IN = infil rate [m/s]
# MR = icemelt rate [m/s]
# Use refs to other comp vars from new framework. (5/18/12)
P = self.P_rain # (This is now liquid-only precip. 9/14/14)
SM = self.SM
GW = self.GW
ET = self.ET
IN = self.IN
MR = self.MR
## if (self.DEBUG):
## print 'At time:', self.time_min, ', P =', P, '[m/s]'
# For testing
## print '(Pmin, Pmax) =', P.min(), P.max()
## print '(SMmin, SMmax) =', SM.min(), SM.max()
## print '(GWmin, GWmax) =', GW.min(), GW.max()
## print '(ETmin, ETmax) =', ET.min(), ET.max()
## print '(INmin, INmax) =', IN.min(), IN.max()
## print '(MRmin, MRmax) =', MR.min(), MR.max()
## # print '(Hmin, Hmax) =', H.min(), H.max()
## print ' '
self.R = (P + SM + GW + MR) - (ET + IN)
# update_R()
def update_R_integral(self):
# Update mass total for R, sum over all pixels
volume = np.double(self.R * self.da * self.dt)
if (np.size(volume) == 1):
self.vol_R += (volume * self.rti.n_pixels)
else:
self.vol_R += np.sum(volume)
# update_R_integral()
def update_discharge(self):
# The discharge grid, Q, gives the flux of water _out_
# of each grid cell. This entire amount then flows
# into one of the 8 neighbor grid cells, as indicated
# by the D8 flow code. The update_flow_volume() function
# is called right after this one in update() and uses
# the Q grid.
# 7/15/05. The cross-sectional area of a trapezoid is
# given by: Ac = d * (w + (d * tan(theta))),
# where w is the bottom width. If we were to
# use: Ac = w * d, then we'd have Ac=0 when w=0.
# We also need angle units to be radians.
# Compute the discharge grid
# A_wet is initialized in <API key>().
# A_wet is updated in update_trapezoid_Rh().
self.Q = np.float64(self.u * A_wet)
self.Q[:] = self.u * self.A_wet ## (2/19/13, in place)
# For testing
## print '(umin, umax) =', self.u.min(), self.u.max()
## print '(d0min, d0max) =', self.d0.min(), self.d0.max()
## print '(dmin, dmax) =', self.d.min(), self.d.max()
## print '(amin, amax) =', self.angle.min(), self.angle.max()
## print '(wmin, wmax) =', self.width.min(), self.width.max()
## print '(Qmin, Qmax) =', self.Q.min(), self.Q.max()
## print '(L2min, L2max) =', L2.min(), L2.max()
## print '(Qmin, Qmax) =', self.Q.min(), self.Q.max()
# For testing
# print 'dmin, dmax =', self.d.min(), self.d.max()
# print 'umin, umax =', self.u.min(), self.u.max()
# print 'Qmin, Qmax =', self.Q.min(), self.Q.max()
# print ' '
# print 'u(outlet) =', self.u[self.outlet_ID]
# Wherever depth is less than z0, assume that water
# is not flowing and set u and Q to zero.
# However, we also need (d gt 0) to avoid a divide
# by zero problem, even when numerators are zero.
# FLOWING = (d > (z0/aval))
# u = (u * FLOWING)
# Q = (Q * FLOWING)
# d = np.maximum(d, 0.0) ;(allow depths lt z0, if gt 0.)
# update_discharge()
def update_diversions(self):
# Note: The Channel component requests the following input
# vars from the Diversions component by including
# them in its "get_input_vars()":
# (1) Q_sources, Q_sources_x, Q_sources_y
# (2) Q_sinks, Q_sinks_x, Q_sinks_y
# (3) Q_canals_out, Q_canals_out_x, Q_canals_out_y
# (4) Q_canals_fraction, Q_canals_in_x, Q_canals_in_y.
# source_IDs are computed from (x,y) coordinates during
# initialize().
# Diversions component needs to get Q_canals_in from the
# Channel component.
# Note: This *must* be called after update_discharge() and
# before update_flow_volume().
# Note: The Q grid stores the volume flow rate *leaving* each
# grid cell in the domain. For sources, an extra amount
# is leaving the cell which can flow into its D8 parent
# cell. For sinks, a lesser amount is leaving the cell
# toward the D8 parent.
# Note: It is not enough to just update Q and then call the
# update_flow_volume() method. This is because it
# won't update the volume in the channels in the grid
# cells that the extra discharge is leaving from.
# If a grid cell contains a "source", then an additional Q
# will flow *into* that grid cell and increase flow volume.
# This is not fully tested but runs. However, the Diversion
# vars are still computed even when Diversions component is
# disabled. So it slows things down somewhat.
return
# Update Q and vol due to point sources
## if (hasattr(self, 'source_IDs')):
if (self.n_sources > 0):
self.Q[ self.source_IDs ] += self.Q_sources
self.vol[ self.source_IDs ] += (self.Q_sources * self.dt)
# Update Q and vol due to point sinks
## if (hasattr(self, 'sink_IDs')):
if (self.n_sinks > 0):
self.Q[ self.sink_IDs ] -= self.Q_sinks
self.vol[ self.sink_IDs ] -= (self.Q_sinks * self.dt)
# Update Q and vol due to point canals
## if (hasattr(self, 'canal_in_IDs')):
if (self.n_canals > 0):
# Q grid was just modified. Apply the canal diversion fractions
# to compute the volume flow rate into upstream ends of canals.
Q_canals_in = self.Q_canals_fraction * self.Q[ self.canal_in_IDs ]
self.Q_canals_in = Q_canals_in
# Update Q and vol due to losses at canal entrances
self.Q[ self.canal_in_IDs ] -= Q_canals_in
self.vol[ self.canal_in_IDs ] -= (Q_canals_in * self.dt)
# Update Q and vol due to gains at canal exits.
# Diversions component accounts for travel time.
self.Q[ self.canal_out_IDs ] += self.Q_canals_out
self.vol[ self.canal_out_IDs ] += (self.Q_canals_out * self.dt)
# update_diversions()
def update_flow_volume(self):
# Notes: This function must be called after
# update_discharge() and update_diversions().
# Notes: Q = surface discharge [m^3/s]
# R = excess precip. rate [m/s]
# da = pixel area [m^2]
# dt = channel flow timestep [s]
# vol = total volume of water in pixel [m^3]
# v2 = temp version of vol
# w1 = IDs of pixels that...
# p1 = IDs of parent pixels that...
dt = self.dt # [seconds]
# Add contribution (or loss ?) from excess rainrate
# Contributions over entire grid cell from rainfall,
# snowmelt, icemelt and baseflow (minus losses from
# evaporation and infiltration) are assumed to flow
# into the channel within the grid cell.
# Note that R is allowed to be negative.
self.vol += (self.R * self.da) * dt # (in place)
# Add contributions from neighbor pixels
# Each grid cell passes flow to *one* downstream neighbor.
# Note that multiple grid cells can flow toward a given grid
# cell, so a grid cell ID may occur in d8.p1 and d8.p2, etc.
# (2/16/10) RETEST THIS. Before, a copy called "v2" was
# used but this doesn't seem to be necessary.
if (self.d8.p1_OK):
self.vol[ self.d8.p1 ] += (dt * self.Q[self.d8.w1])
if (self.d8.p2_OK):
self.vol[ self.d8.p2 ] += (dt * self.Q[self.d8.w2])
if (self.d8.p3_OK):
self.vol[ self.d8.p3 ] += (dt * self.Q[self.d8.w3])
if (self.d8.p4_OK):
self.vol[ self.d8.p4 ] += (dt * self.Q[self.d8.w4])
if (self.d8.p5_OK):
self.vol[ self.d8.p5 ] += (dt * self.Q[self.d8.w5])
if (self.d8.p6_OK):
self.vol[ self.d8.p6 ] += (dt * self.Q[self.d8.w6])
if (self.d8.p7_OK):
self.vol[ self.d8.p7 ] += (dt * self.Q[self.d8.w7])
if (self.d8.p8_OK):
self.vol[ self.d8.p8 ] += (dt * self.Q[self.d8.w8])
# Subtract the amount that flows out to D8 neighbor
self.vol -= (self.Q * dt) # (in place)
# While R can be positive or negative, the surface flow
# volume must always be nonnegative. This also ensures
# that the flow depth is nonnegative. (7/13/06)
## self.vol = np.maximum(self.vol, 0.0)
## self.vol[:] = np.maximum(self.vol, 0.0) # (2/19/13)
np.maximum( self.vol, 0.0, self.vol ) # (in place)
# update_flow_volume
def update_flow_depth(self):
# Notes: 7/18/05. Modified to use the equation for volume
# of a trapezoidal channel: vol = Ac * ds, where
# Ac=d*[w + d*tan(t)], and to solve the resulting
# quadratic (discarding neg. root) for new depth, d.
# 8/29/05. Now original ds is used for subsurface
# flow and there is a ds_chan which can include a
# sinuosity greater than 1. This may be especially
# important for larger pixel sizes.
# Removed (ds > 1) here which was only meant to
# avoid a "divide by zero" error at pixels where
# (ds eq 0). This isn't necessary since the
# Flow_Lengths function in utils_TF.pro never
# returns a value of zero.
# Modified to avoid double where calls, which
# reduced cProfile run time for this method from
# 1.391 to 0.644. (9/23/14)
# Commented this out on (2/18/10) because it doesn't
# seem to be used anywhere now. Checked all
# of the Channels components.
# self.d_last = self.d.copy()
# Make some local aliases and vars
# Note: angles were read as degrees & converted to radians
d = self.d
width = self.width
angle = self.angle
SCALAR_ANGLES = (np.size(angle) == 1)
# (2/18/10) New code to deal with case where the flow
# depth exceeds a bankfull depth.
# For now, d_bankfull is hard-coded.
# CHANGE Manning's n here, too?
d_bankfull = 4.0 # [meters]
wb = (self.d > d_bankfull) # (array of True or False)
self.width[ wb ] = self.d8.dw[ wb ]
if not(SCALAR_ANGLES):
self.angle[ wb ] = 0.0
# w_overbank = np.where( d > d_bankfull )
# n_overbank = np.size( w_overbank[0] )
# if (n_overbank != 0):
# width[ w_overbank ] = self.d8.dw[ w_overbank ]
# if not(SCALAR_ANGLES): angle[w_overbank] = 0.0
# (2/18/10) New code to deal with case where the top
# width exceeds the grid cell width, dw.
top_width = width + (2.0 * d * np.sin(self.angle))
wb = (top_width > self.d8.dw) # (array of True or False)
self.width[ wb ] = self.d8.dw[ wb ]
if not(SCALAR_ANGLES):
self.angle[ wb ] = 0.0
# wb = np.where(top_width > self.d8.dw)
# nb = np.size(w_bad[0])
# if (nb != 0):
# width[ wb ] = self.d8.dw[ wb ]
# if not(SCALAR_ANGLES): angle[ wb ] = 0.0
# Is "angle" a scalar or a grid ?
if (SCALAR_ANGLES):
if (angle == 0.0):
d = self.vol / (width * self.d8.ds)
else:
denom = 2.0 * np.tan(angle)
arg = 2.0 * denom * self.vol / self.d8.ds
arg += width**(2.0)
d = (np.sqrt(arg) - width) / denom
else:
# Pixels where angle is 0 must be handled separately
w1 = ( angle == 0 ) # (arrays of True or False)
w2 = np.invert( w1 )
A_top = width[w1] * self.d8.ds[w1]
d[w1] = self.vol[w1] / A_top
denom = 2.0 * np.tan(angle[w2])
arg = 2.0 * denom * self.vol[w2] / self.d8.ds[w2]
arg += width[w2]**(2.0)
d[w2] = (np.sqrt(arg) - width[w2]) / denom
# Pixels where angle is 0 must be handled separately
# wz = np.where( angle == 0 )
# nwz = np.size( wz[0] )
# wzc = np.where( angle != 0 )
# nwzc = np.size( wzc[0] )
# if (nwz != 0):
# A_top = width[wz] * self.d8.ds[wz]
# ## A_top = self.width[wz] * self.d8.ds_chan[wz]
# d[wz] = self.vol[wz] / A_top
# if (nwzc != 0):
# term1 = 2.0 * np.tan(angle[wzc])
# arg = 2.0 * term1 * self.vol[wzc] / self.d8.ds[wzc]
# arg += width[wzc]**(2.0)
# d[wzc] = (np.sqrt(arg) - width[wzc]) / term1
# Set depth values on edges to zero since
# they become spikes (no outflow) 7/15/06
d[ self.d8.noflow_IDs ] = 0.0
# 4/19/06. Force flow depth to be positive ?
# This seems to be needed with the non-Richards
# infiltration routines when starting with zero
# depth everywhere, since all water infiltrates
# for some period of time. It also seems to be
# needed more for short rainfall records to
# avoid a negative flow depth error.
# 7/13/06. Still needed for Richards method
## self.d = np.maximum(d, 0.0)
np.maximum(d, 0.0, self.d) # (2/19/13, in place)
# Find where d <= 0 and save for later (9/23/14)
self.d_is_pos = (self.d > 0)
self.d_is_neg = np.invert( self.d_is_pos )
# update_flow_depth
def <API key>(self):
# Notes: It is assumed that the flow directions don't
# change even though the free surface is changing.
delta_d = (self.d - self.d[self.d8.parent_IDs])
self.S_free[:] = self.S_bed + (delta_d / self.d8.ds)
# Don't do this; negative slopes are needed
# to decelerate flow in dynamic wave case
# and for backwater effects.
# Set negative slopes to zero
self.S_free = np.maximum(self.S_free, 0)
# <API key>()
def update_shear_stress(self):
# Notes: 9/9/14. Added so shear stress could be shared.
# This uses the depth-slope product.
if (self.KINEMATIC_WAVE):
slope = self.S_bed
else:
slope = self.S_free
self.tau[:] = self.rho_H2O * self.g * self.d * slope
# update_shear_stress()
def update_shear_speed(self):
# Notes: 9/9/14. Added so shear speed could be shared.
self.u_star[:] = np.sqrt( self.tau / self.rho_H2O )
# update_shear_speed()
def update_trapezoid_Rh(self):
# Notes: Compute the hydraulic radius of a trapezoid that:
# (1) has a bed width of wb >= 0 (0 for triangular)
# (2) has a bank angle of theta (0 for rectangular)
# (3) is filled with water to a depth of d.
# The units of wb and d are meters. The units of
# theta are assumed to be degrees and are converted.
# NB! wb should never be zero, so P_wet can never be 0,
# which would produce a NaN (divide by zero).
# See Notes for TF_Tan function in utils_TF.pro
# AW = d * (wb + (d * TF_Tan(theta_rad)) )
# 9/9/14. Bug fix. Angles were already in radians but
# were converted to radians again.
# Compute hydraulic radius grid for trapezoidal channels
# Note: angles were read as degrees & converted to radians
d = self.d # (local synonyms)
wb = self.width # (trapezoid bottom width)
L2 = d * np.tan( self.angle )
A_wet = d * (wb + L2)
P_wet = wb + (np.float64(2) * d / np.cos(self.angle) )
# At noflow_IDs (e.g. edges) P_wet may be zero
# so do this to avoid "divide by zero". (10/29/11)
P_wet[ self.d8.noflow_IDs ] = np.float64(1)
Rh = (A_wet / P_wet)
# w = np.where(P_wet == 0)
# print 'In update_trapezoid_Rh():'
# print ' P_wet= 0 at', w[0].size, 'cells'
# Force edge pixels to have Rh = 0.
# This will make u = 0 there also.
Rh[ self.d8.noflow_IDs ] = np.float64(0)
## w = np.where(wb <= 0)
## nw = np.size(w[0])
## if (nw > 0): Rh[w] = np.float64(0)
self.Rh[:] = Rh
self.A_wet[:] = A_wet ## (Now shared: 9/9/14)
self.P_wet[:] = P_wet ## (Now shared: 9/9/14)
# For testing
## print 'dmin, dmax =', d.min(), d.max()
## print 'wmin, wmax =', wb.min(), wb.max()
## print 'amin, amax =', self.angle.min(), self.angle.max()
# update_trapezoid_Rh()
def <API key>(self):
# Note: Added on 9/9/14 to streamline.
# Note: f = half of the Fanning friction factor
# d = flow depth [m]
# z0 = roughness length
# S = bed slope (assumed equal to friction slope)
# g = 9.81 = gravitation constant [m/s^2]
# For law of the wall:
# kappa = 0.41 = von Karman's constant
# aval = 0.48 = integration constant
# law_const = sqrt(g)/kappa = 7.6393d
# smoothness = (aval / z0) * d
# f = (kappa / alog(smoothness))^2d
# tau_bed = rho_w * f * u^2 = rho_w * g * d * S
# d, S, and z0 can be arrays.
# To make default z0 correspond to default
# Manning's n, can use this approximation:
# z0 = a * (2.34 * sqrt(9.81) * n / kappa)^6d
# For n=0.03, this gives: z0 = 0.011417
# However, for n=0.3, it gives: z0 = 11417.413
# which is 11.4 km! So the approximation only
# holds within some range of values.
# cProfile: This method took: 0.369 secs for topoflow_test()
# Find where (d <= 0). g=good, b=bad
wg = self.d_is_pos
wb = self.d_is_neg
# wg = ( self.d > 0 )
# wb = np.invert( wg )
# Compute f for Manning case
# This makes f=0 and du=0 where (d <= 0)
if (self.MANNING):
n2 = self.nval ** np.float64(2)
self.f[ wg ] = self.g * (n2[wg] / (self.d[wg] ** self.one_third))
self.f[ wb ] = np.float64(0)
# Compute f for Law of Wall case
if (self.LAW_OF_WALL):
# Make sure (smoothness > 1) before taking log.
# Should issue a warning if this is used.
smoothness = (self.aval / self.z0val) * self.d
np.maximum(smoothness, np.float64(1.1), smoothness) # (in place)
self.f[wg] = (self.kappa / np.log(smoothness[wg])) ** np.float64(2)
self.f[wb] = np.float64(0)
# cProfile: This method took: 0.93 secs for topoflow_test()
# # Find where (d <= 0). g=good, b=bad
# wg = np.where( self.d > 0 )
# ng = np.size( wg[0])
# wb = np.where( self.d <= 0 )
# nb = np.size( wb[0] )
# # Compute f for Manning case
# # This makes f=0 and du=0 where (d <= 0)
# if (self.MANNING):
# n2 = self.nval ** np.float64(2)
# if (ng != 0):
# self.f[wg] = self.g * (n2[wg] / (self.d[wg] ** self.one_third))
# if (nb != 0):
# self.f[wb] = np.float64(0)
# # Compute f for Law of Wall case
# if (self.LAW_OF_WALL):
# # Make sure (smoothness > 1) before taking log.
# # Should issue a warning if this is used.
# smoothness = (self.aval / self.z0val) * self.d
# np.maximum(smoothness, np.float64(1.1), smoothness) # (in place)
# ## smoothness = np.maximum(smoothness, np.float64(1.1))
# if (ng != 0):
# self.f[wg] = (self.kappa / np.log(smoothness[wg])) ** np.float64(2)
# if (nb != 0):
# self.f[wb] = np.float64(0)
# We could share the Fanning friction factor
self.fanning = (np.float64(2) * self.f)
# <API key>()
def update_velocity(self):
# Note: Do nothing now unless this method is overridden
# by a particular method of computing velocity.
print "Warning: update_velocity() method is inactive."
# print 'KINEMATIC WAVE =', self.KINEMATIC_WAVE
# print 'DIFFUSIVE WAVE =', self.DIFFUSIVE_WAVE
# print 'DYNAMIC WAVE =', self.DYNAMIC_WAVE
# update_velocity()
def <API key>(self):
# Force edge pixels to have u=0.
# Large slope around 1 flows into small
# slope & leads to a negative velocity.
self.u[ self.d8.noflow_IDs ] = np.float64(0)
# <API key>()
def <API key>(self):
# Notes: 9/9/14. Added so Froude number could be shared.
# This use of wg & wb reduced cProfile time from:
# 0.644 sec to: 0.121. (9/23/14)
# g = good, b = bad
wg = self.d_is_pos
wb = self.d_is_neg
self.froude[ wg ] = self.u[wg] / np.sqrt( self.g * self.d[wg] )
self.froude[ wb ] = np.float64(0)
# <API key>()
def <API key>(self):
# Save computed values at outlet, which are used
# by the TopoFlow driver.
# Note that Q_outlet, etc. are defined as 0D numpy
# arrays to make them "mutable scalars" (i.e.
# this allows changes to be seen by other components
# who have a reference. To preserver the reference,
# however, we must use fill() to assign a new value.
Q_outlet = self.Q[ self.outlet_ID ]
u_outlet = self.u[ self.outlet_ID ]
d_outlet = self.d[ self.outlet_ID ]
f_outlet = self.f[ self.outlet_ID ]
self.Q_outlet.fill( Q_outlet )
self.u_outlet.fill( u_outlet )
self.d_outlet.fill( d_outlet )
self.f_outlet.fill( f_outlet )
## self.Q_outlet.fill( self.Q[ self.outlet_ID ] )
## self.u_outlet.fill( self.u[ self.outlet_ID ] )
## self.d_outlet.fill( self.d[ self.outlet_ID ] )
## self.f_outlet.fill( self.f[ self.outlet_ID ] )
## self.Q_outlet = self.Q[ self.outlet_ID ]
## self.u_outlet = self.u[ self.outlet_ID ]
## self.d_outlet = self.d[ self.outlet_ID ]
## self.f_outlet = self.f[ self.outlet_ID ]
## self.Q_outlet = self.Q.flat[self.outlet_ID]
## self.u_outlet = self.u.flat[self.outlet_ID]
## self.d_outlet = self.d.flat[self.outlet_ID]
## self.f_outlet = self.f.flat[self.outlet_ID]
# <API key>()
def update_peak_values(self):
if (self.Q_outlet > self.Q_peak):
self.Q_peak.fill( self.Q_outlet )
self.T_peak.fill( self.time_min ) # (time to peak)
if (self.u_outlet > self.u_peak):
self.u_peak.fill( self.u_outlet )
self.Tu_peak.fill( self.time_min )
if (self.d_outlet > self.d_peak):
self.d_peak.fill( self.d_outlet )
self.Td_peak.fill( self.time_min )
## if (self.Q_outlet > self.Q_peak):
## self.Q_peak = self.Q_outlet
## self.T_peak = self.time_min # (time to peak)
## if (self.u_outlet > self.u_peak):
## self.u_peak = self.u_outlet
## self.Tu_peak = self.time_min
## if (self.d_outlet > self.d_peak):
## self.d_peak = self.d_outlet
## self.Td_peak = self.time_min
# update_peak_values()
def <API key>(self):
# Note: Renamed "volume_out" to "vol_Q" for consistency
# with vol_P, vol_SM, vol_IN, vol_ET, etc. (5/18/12)
self.vol_Q += (self.Q_outlet * self.dt) ## Experiment: 5/19/12.
## self.vol_Q += (self.Q[self.outlet_ID] * self.dt)
# <API key>()
def <API key>(self, REPORT=False):
# Get mins and max over entire domain
## Q_min = self.Q.min()
## Q_max = self.Q.max()
## u_min = self.u.min()
## u_max = self.u.max()
## d_min = self.d.min()
## d_max = self.d.max()
# Exclude edges where mins are always zero.
nx = self.nx
ny = self.ny
Q_min = self.Q[1:(ny - 2)+1,1:(nx - 2)+1].min()
Q_max = self.Q[1:(ny - 2)+1,1:(nx - 2)+1].max()
u_min = self.u[1:(ny - 2)+1,1:(nx - 2)+1].min()
u_max = self.u[1:(ny - 2)+1,1:(nx - 2)+1].max()
d_min = self.d[1:(ny - 2)+1,1:(nx - 2)+1].min()
d_max = self.d[1:(ny - 2)+1,1:(nx - 2)+1].max()
# (2/6/13) This preserves "mutable scalars" that
# can be accessed as refs by other components.
if (Q_min < self.Q_min):
self.Q_min.fill( Q_min )
if (Q_max > self.Q_max):
self.Q_max.fill( Q_max )
if (u_min < self.u_min):
self.u_min.fill( u_min )
if (u_max > self.u_max):
self.u_max.fill( u_max )
if (d_min < self.d_min):
self.d_min.fill( d_min )
if (d_max > self.d_max):
self.d_max.fill( d_max )
# (2/6/13) This preserves "mutable scalars" that
# can be accessed as refs by other components.
## self.Q_min.fill( np.minimum( self.Q_min, Q_min ) )
## self.Q_max.fill( np.maximum( self.Q_max, Q_max ) )
## self.u_min.fill( np.minimum( self.u_min, u_min ) )
## self.u_max.fill( np.maximum( self.u_max, u_max ) )
## self.d_min.fill( np.minimum( self.d_min, d_min ) )
## self.d_max.fill( np.maximum( self.d_max, d_max ) )
# (2/6/13) This preserves "mutable scalars" that
# can be accessed as refs by other components.
## self.Q_min.fill( min( self.Q_min, Q_min ) )
## self.Q_max.fill( max( self.Q_max, Q_max ) )
## self.u_min.fill( min( self.u_min, u_min ) )
## self.u_max.fill( max( self.u_max, u_max ) )
## self.d_min.fill( min( self.d_min, d_min ) )
## self.d_max.fill( max( self.d_max, d_max ) )
# (2/6/13) This produces "immutable scalars".
## self.Q_min = self.Q.min()
## self.Q_max = self.Q.max()
## self.u_min = self.u.min()
## self.u_max = self.u.max()
## self.d_min = self.d.min()
## self.d_max = self.d.max()
if (REPORT):
print 'In channels_base.<API key>():'
print '(dmin, dmax) =', self.d_min, self.d_max
print '(umin, umax) =', self.u_min, self.u_max
print '(Qmin, Qmax) =', self.Q_min, self.Q_max
print ' '
# <API key>()
def check_flow_depth(self):
OK = True
d = self.d
dt = self.dt
nx = self.nx
# All all flow depths positive ?
wbad = np.where( np.logical_or( d < 0.0, np.logical_not(np.isfinite(d)) ))
nbad = np.size( wbad[0] )
if (nbad == 0):
return OK
OK = False
dmin = d[wbad].min()
star_line = '*******************************************'
msg = [ star_line, \
'ERROR: Simulation aborted.', ' ', \
'Negative depth found: ' + str(dmin), \
'Time step may be too large.', \
'Time step: ' + str(dt) + ' [s]', ' ']
for k in xrange(len(msg)):
print msg[k]
# If not too many, print actual velocities
if (nbad < 30):
brow = wbad[0][0]
bcol = wbad[1][0]
## badi = wbad[0]
## bcol = (badi % nx)
## brow = (badi / nx)
crstr = str(bcol) + ', ' + str(brow)
msg = ['(Column, Row): ' + crstr, \
'Flow depth: ' + str(d[brow, bcol])]
for k in xrange(len(msg)):
print msg[k]
print star_line
print ' '
return OK
# check_flow_depth
def check_flow_velocity(self):
OK = True
u = self.u
dt = self.dt
nx = self.nx
# Are all velocities positive ?
wbad = np.where( np.logical_or( u < 0.0, np.logical_not(np.isfinite(u)) ))
nbad = np.size( wbad[0] )
if (nbad == 0):
return OK
OK = False
umin = u[wbad].min()
star_line = '*******************************************'
msg = [ star_line, \
'ERROR: Simulation aborted.', ' ', \
'Negative or NaN velocity found: ' + str(umin), \
'Time step may be too large.', \
'Time step: ' + str(dt) + ' [s]', ' ']
for k in xrange(len(msg)):
print msg[k]
# If not too many, print actual velocities
if (nbad < 30):
brow = wbad[0][0]
bcol = wbad[1][0]
## badi = wbad[0]
## bcol = (badi % nx)
## brow = (badi / nx)
crstr = str(bcol) + ', ' + str(brow)
msg = ['(Column, Row): ' + crstr, \
'Velocity: ' + str(u[brow, bcol])]
for k in xrange(len(msg)):
print msg[k]
print star_line
print ' '
return OK
## umin = u[wbad].min()
## badi = wbad[0]
## bcol = (badi % nx)
## brow = (badi / nx)
## crstr = str(bcol) + ', ' + str(brow)
## msg = np.array([' ', \
## 'ERROR: Simulation aborted.', ' ', \
## 'Negative velocity found: ' + str(umin), \
## 'Time step may be too large.', ' ', \
## '(Column, Row): ' + crstr, \
## 'Velocity: ' + str(u[badi]), \
## 'Time step: ' + str(dt) + ' [s]', \
## for k in xrange( np.size(msg) ):
## print msg[k]
## return OK
# check_flow_velocity
def open_input_files(self):
# This doesn't work, because file_unit doesn't get full path. (10/28/11)
# start_dir = os.getcwd()
# os.chdir( self.in_directory )
in_files = ['slope_file', 'nval_file', 'z0val_file',
'width_file', 'angle_file', 'sinu_file', 'd0_file']
self.prepend_directory( in_files, INPUT=True )
# self.slope_file = self.in_directory + self.slope_file
# self.nval_file = self.in_directory + self.nval_file
# self.z0val_file = self.in_directory + self.z0val_file
# self.width_file = self.in_directory + self.width_file
# self.angle_file = self.in_directory + self.angle_file
# self.sinu_file = self.in_directory + self.sinu_file
# self.d0_file = self.in_directory + self.d0_file
#self.code_unit = model_input.open_file(self.code_type, self.code_file)
self.slope_unit = model_input.open_file(self.slope_type, self.slope_file)
if (self.MANNING):
self.nval_unit = model_input.open_file(self.nval_type, self.nval_file)
if (self.LAW_OF_WALL):
self.z0val_unit = model_input.open_file(self.z0val_type, self.z0val_file)
self.width_unit = model_input.open_file(self.width_type, self.width_file)
self.angle_unit = model_input.open_file(self.angle_type, self.angle_file)
self.sinu_unit = model_input.open_file(self.sinu_type, self.sinu_file)
self.d0_unit = model_input.open_file(self.d0_type, self.d0_file)
# os.chdir( start_dir )
# open_input_files()
def read_input_files(self):
# The flow codes are always a grid, size of DEM.
# NB! model_input.py also has a read_grid() function.
rti = self.rti
## print 'Reading D8 flow grid (in CHANNELS)...'
## self.code = rtg_files.read_grid(self.code_file, rti,
## RTG_type='BYTE')
## print ' '
# All grids are assumed to have a data type of Float32.
slope = model_input.read_next(self.slope_unit, self.slope_type, rti)
if (slope != None): self.slope = slope
# If EOF was reached, hopefully numpy's "fromfile"
# returns None, so that the stored value will be
# the last value that was read.
if (self.MANNING):
nval = model_input.read_next(self.nval_unit, self.nval_type, rti)
if (nval != None):
self.nval = nval
self.nval_min = nval.min()
self.nval_max = nval.max()
if (self.LAW_OF_WALL):
z0val = model_input.read_next(self.z0val_unit, self.z0val_type, rti)
if (z0val != None):
self.z0val = z0val
self.z0val_min = z0val.min()
self.z0val_max = z0val.max()
width = model_input.read_next(self.width_unit, self.width_type, rti)
if (width != None): self.width = width
angle = model_input.read_next(self.angle_unit, self.angle_type, rti)
if (angle != None):
# Convert bank angles from degrees to radians.
self.angle = angle * self.deg_to_rad # [radians]
self.angle = angle # (before 9/9/14)
sinu = model_input.read_next(self.sinu_unit, self.sinu_type, rti)
if (sinu != None): self.sinu = sinu
d0 = model_input.read_next(self.d0_unit, self.d0_type, rti)
if (d0 != None): self.d0 = d0
## code = model_input.read_grid(self.code_unit, \
## self.code_type, rti, dtype='UInt8')
## if (code != None): self.code = code
# read_input_files()
def close_input_files(self):
# if not(self.slope_unit.closed):
# if (self.slope_unit != None):
# NB! self.code_unit was never defined as read.
# if (self.code_type != 'scalar'): self.code_unit.close()
if (self.slope_type != 'Scalar'): self.slope_unit.close()
if (self.MANNING):
if (self.nval_type != 'Scalar'): self.nval_unit.close()
if (self.LAW_OF_WALL):
if (self.z0val_type != 'Scalar'): self.z0val_unit.close()
if (self.width_type != 'Scalar'): self.width_unit.close()
if (self.angle_type != 'Scalar'): self.angle_unit.close()
if (self.sinu_type != 'Scalar'): self.sinu_unit.close()
if (self.d0_type != 'Scalar'): self.d0_unit.close()
## if (self.slope_file != ''): self.slope_unit.close()
## if (self.MANNING):
## if (self.nval_file != ''): self.nval_unit.close()
## if (self.LAW_OF_WALL):
## if (self.z0val_file != ''): self.z0val_unit.close()
## if (self.width_file != ''): self.width_unit.close()
## if (self.angle_file != ''): self.angle_unit.close()
## if (self.sinu_file != ''): self.sinu_unit.close()
## if (self.d0_file != ''): self.d0_unit.close()
# close_input_files()
def <API key>(self):
# Notes: Append out_directory to outfile names.
self.Q_gs_file = (self.out_directory + self.Q_gs_file)
self.u_gs_file = (self.out_directory + self.u_gs_file)
self.d_gs_file = (self.out_directory + self.d_gs_file)
self.f_gs_file = (self.out_directory + self.f_gs_file)
self.Q_ts_file = (self.out_directory + self.Q_ts_file)
self.u_ts_file = (self.out_directory + self.u_ts_file)
self.d_ts_file = (self.out_directory + self.d_ts_file)
self.f_ts_file = (self.out_directory + self.f_ts_file)
# <API key>()
def bundle_output_files(self):
# NOT READY YET. Need "get_long_name()" and a new
# version of "get_var_units". (9/21/14)
# Bundle the output file info into an array for convenience.
# Then we just need one open_output_files(), in BMI_base.py,
# and one close_output_files(). Less to maintain. (9/21/14)
# gs = grid stack, ts = time series, ps = profile series.
self.out_files = [
{var_name:'Q',
save_gs:self.SAVE_Q_GRIDS, gs_file:self.Q_gs_file,
save_ts:self.SAVE_Q_PIXELS, ts_file:self.Q_ts_file,
long_name:get_long_name('Q'), units_name:get_var_units('Q')},
{var_name:'u',
save_gs:self.SAVE_U_GRIDS, gs_file:self.u_gs_file,
save_ts:self.SAVE_U_PIXELS, ts_file:self.u_ts_file,
long_name:get_long_name('u'), units_name:get_var_units('u')},
{var_name:'d',
save_gs:self.SAVE_D_GRIDS, gs_file:self.d_gs_file,
save_ts:self.SAVE_D_PIXELS, ts_file:self.d_ts_file,
long_name:get_long_name('d'), units_name:get_var_units('d')},
{var_name:'f',
save_gs:self.SAVE_F_GRIDS, gs_file:self.f_gs_file,
save_ts:self.SAVE_F_PIXELS, ts_file:self.f_ts_file,
long_name:get_long_name('f'), units_name:get_var_units('f')} ]
# bundle_output_files
def open_output_files(self):
model_output.check_netcdf()
self.<API key>()
## self.bundle_output_files()
## print 'self.SAVE_Q_GRIDS =', self.SAVE_Q_GRIDS
## print 'self.SAVE_U_GRIDS =', self.SAVE_U_GRIDS
## print 'self.SAVE_D_GRIDS =', self.SAVE_D_GRIDS
## print 'self.SAVE_F_GRIDS =', self.SAVE_F_GRIDS
## print 'self.SAVE_Q_PIXELS =', self.SAVE_Q_PIXELS
## print 'self.SAVE_U_PIXELS =', self.SAVE_U_PIXELS
## print 'self.SAVE_D_PIXELS =', self.SAVE_D_PIXELS
## print 'self.SAVE_F_PIXELS =', self.SAVE_F_PIXELS
# IDs = self.outlet_IDs
# for k in xrange( len(self.out_files) ):
# # Open new files to write grid stacks
# if (self.out_files[k].save_gs):
# model_output.open_new_gs_file( self, self.out_files[k], self.rti )
# # Open new files to write time series
# if (self.out_files[k].save_ts):
# model_output.open_new_ts_file( self, self.out_files[k], IDs )
# Open new files to write grid stacks
if (self.SAVE_Q_GRIDS):
model_output.open_new_gs_file( self, self.Q_gs_file, self.rti,
var_name='Q',
long_name='<API key>',
units_name='m^3/s')
if (self.SAVE_U_GRIDS):
model_output.open_new_gs_file( self, self.u_gs_file, self.rti,
var_name='u',
long_name='<API key>',
units_name='m/s')
if (self.SAVE_D_GRIDS):
model_output.open_new_gs_file( self, self.d_gs_file, self.rti,
var_name='d',
long_name='<API key>',
units_name='m')
if (self.SAVE_F_GRIDS):
model_output.open_new_gs_file( self, self.f_gs_file, self.rti,
var_name='f',
long_name='friction_factor',
units_name='none')
# Open new files to write time series
IDs = self.outlet_IDs
if (self.SAVE_Q_PIXELS):
model_output.open_new_ts_file( self, self.Q_ts_file, IDs,
var_name='Q',
long_name='<API key>',
units_name='m^3/s')
if (self.SAVE_U_PIXELS):
model_output.open_new_ts_file( self, self.u_ts_file, IDs,
var_name='u',
long_name='<API key>',
units_name='m/s')
if (self.SAVE_D_PIXELS):
model_output.open_new_ts_file( self, self.d_ts_file, IDs,
var_name='d',
long_name='<API key>',
units_name='m')
if (self.SAVE_F_PIXELS):
model_output.open_new_ts_file( self, self.f_ts_file, IDs,
var_name='f',
long_name='friction_factor',
units_name='none')
# open_output_files()
def write_output_files(self, time_seconds=None):
# Notes: This function was written to use only model
# time (maybe from a caller) in seconds, and
# the save_grid_dt and save_pixels_dt parameters
# read by read_cfg_file().
# read_cfg_file() makes sure that all of
# the "save_dts" are larger than or equal to the
# process dt.
# Allows time to be passed from a caller
if (time_seconds is None):
time_seconds = self.time_sec
model_time = int(time_seconds)
# Save computed values at sampled times
if (model_time % int(self.save_grid_dt) == 0):
self.save_grids()
if (model_time % int(self.save_pixels_dt) == 0):
self.save_pixel_values()
# Save computed values at sampled times
## if ((self.time_index % self.grid_save_step) == 0):
## self.save_grids()
## if ((self.time_index % self.pixel_save_step) == 0):
## self.save_pixel_values()
# write_output_files()
def close_output_files(self):
if (self.SAVE_Q_GRIDS): model_output.close_gs_file( self, 'Q')
if (self.SAVE_U_GRIDS): model_output.close_gs_file( self, 'u')
if (self.SAVE_D_GRIDS): model_output.close_gs_file( self, 'd')
if (self.SAVE_F_GRIDS): model_output.close_gs_file( self, 'f')
if (self.SAVE_Q_PIXELS): model_output.close_ts_file( self, 'Q')
if (self.SAVE_U_PIXELS): model_output.close_ts_file( self, 'u')
if (self.SAVE_D_PIXELS): model_output.close_ts_file( self, 'd')
if (self.SAVE_F_PIXELS): model_output.close_ts_file( self, 'f')
# close_output_files()
def save_grids(self):
# Save grid stack to a netCDF file
# Note that add_grid() methods will convert
# var from scalar to grid now, if necessary.
if (self.SAVE_Q_GRIDS):
model_output.add_grid( self, self.Q, 'Q', self.time_min )
if (self.SAVE_U_GRIDS):
model_output.add_grid( self, self.u, 'u', self.time_min )
if (self.SAVE_D_GRIDS):
model_output.add_grid( self, self.d, 'd', self.time_min )
if (self.SAVE_F_GRIDS):
model_output.add_grid( self, self.f, 'f', self.time_min )
# save_grids()
def save_pixel_values(self):
IDs = self.outlet_IDs
time = self.time_min
# New method
if (self.SAVE_Q_PIXELS):
model_output.add_values_at_IDs( self, time, self.Q, 'Q', IDs )
if (self.SAVE_U_PIXELS):
model_output.add_values_at_IDs( self, time, self.u, 'u', IDs )
if (self.SAVE_D_PIXELS):
model_output.add_values_at_IDs( self, time, self.d, 'd', IDs )
if (self.SAVE_F_PIXELS):
model_output.add_values_at_IDs( self, time, self.f, 'f', IDs )
# save_pixel_values()
def manning_formula(self):
# Notes: R = (A/P) = hydraulic radius [m]
# N = Manning's roughness coefficient
# (usually in the range 0.012 to 0.035)
# S = bed slope or free slope
# R,S, and N may be 2D arrays.
# If length units are all *feet*, then an extra
# factor of 1.49 must be applied. If units are
# meters, no such factor is needed.
# Note that Q = Ac * u, where Ac is cross-section
# area. For a trapezoid, Ac does not equal w*d.
if (self.KINEMATIC_WAVE):
S = self.S_bed
else:
S = self.S_free
u = (self.Rh ** self.two_thirds) * np.sqrt(S) / self.nval
# Add a hydraulic jump option for when u gets too big ?
return u
# manning_formula()
def law_of_the_wall(self):
# Notes: u = flow velocity [m/s]
# d = flow depth [m]
# z0 = roughness length
# S = bed slope or free slope
# g = 9.81 = gravitation constant [m/s^2]
# kappa = 0.41 = von Karman's constant
# aval = 0.48 = integration constant
# law_const = sqrt(g)/kappa = 7.6393d
# smoothness = (aval / z0) * d
# f = (kappa / alog(smoothness))^2d
# tau_bed = rho_w * f * u^2 = rho_w * g * d * S
# d, S, and z0 can be arrays.
# To make default z0 correspond to default
# Manning's n, can use this approximation:
# z0 = a * (2.34 * sqrt(9.81) * n / kappa)^6d
# For n=0.03, this gives: z0 = 0.011417
# However, for n=0.3, it gives: z0 = 11417.413
# which is 11.4 km! So the approximation only
# holds within some range of values.
if (self.KINEMATIC_WAVE):
S = self.S_bed
else:
S = self.S_free
smoothness = (self.aval / self.z0val) * self.d
# Make sure (smoothness > 1) before taking log.
# Should issue a warning if this is used.
smoothness = np.maximum(smoothness, np.float64(1.1))
u = self.law_const * np.sqrt(self.Rh * S) * np.log(smoothness)
# Add a hydraulic jump option for when u gets too big ?
return u
# law_of_the_wall()
def print_status_report(self):
# Wherever depth is less than z0, assume that water
# is not flowing and set u and Q to zero.
# However, we also need (d gt 0) to avoid a divide
# by zero problem, even when numerators are zero.
# FLOWING = (d > (z0/aval))
wflow = np.where( FLOWING != 0 )
n_flow = np.size( wflow[0] )
n_pixels = self.rti.n_pixels
percent = np.float64(100.0) * (np.float64(n_flow) / n_pixels)
fstr = ('%5.1f' % percent) + '%'
# fstr = idl_func.string(percent, format='(F5.1)').strip() + '%'
print ' Percentage of pixels with flow = ' + fstr
print ' '
self.<API key>(REPORT=True)
wmax = np.where(self.Q == self.Q_max)
nwmax = np.size(wmax[0])
print ' Max(Q) occurs at: ' + str( wmax[0] )
#print,' Max attained at ', nwmax, ' pixels.'
print ' '
print '
# print_status_report()
def remove_bad_slopes(self, FLOAT=False):
# Notes: The main purpose of this routine is to find
# pixels that have nonpositive slopes and replace
# then with the smallest value that occurs anywhere
# in the input slope grid. For example, pixels on
# the edges of the DEM will have a slope of zero.
# With the Kinematic Wave option, flow cannot leave
# a pixel that has a slope of zero and the depth
# increases in an unrealistic manner to create a
# spike in the depth grid.
# It would be better, of course, if there were
# no zero-slope pixels in the DEM. We could use
# an "Imposed gradient DEM" to get slopes or some
# method of "profile smoothing".
# It is possible for the flow code to be nonzero
# at a pixel that has NaN for its slope. For these
# pixels, we also set the slope to our min value.
# 7/18/05. Broke this out into separate procedure.
# Are there any "bad" pixels ?
# If not, return with no messages.
wb = np.where(np.logical_or((self.slope <= 0.0), \
np.logical_not(np.isfinite(self.slope))))
nbad = np.size(wb[0])
print 'size(slope) =', np.size(self.slope)
print 'size(wb) =', nbad
wg = np.where(np.invert(np.logical_or((self.slope <= 0.0), \
np.logical_not(np.isfinite(self.slope)))))
ngood = np.size(wg[0])
if (nbad == 0) or (ngood == 0):
return
# Find smallest positive value in slope grid
# and replace the "bad" values with smin.
print '
print 'WARNING: Zero or negative slopes found.'
print ' Replacing them with smallest slope.'
print ' Use "Profile smoothing tool" instead.'
S_min = self.slope[wg].min()
S_max = self.slope[wg].max()
print ' min(S) = ' + str(S_min)
print ' max(S) = ' + str(S_max)
print '
print ' '
self.slope[wb] = S_min
# Convert data type to double ?
if (FLOAT):
self.slope = np.float32(self.slope)
else:
self.slope = np.float64(self.slope)
# remove_bad_slopes
def Trapezoid_Rh(d, wb, theta):
# Notes: Compute the hydraulic radius of a trapezoid that:
# (1) has a bed width of wb >= 0 (0 for triangular)
# (2) has a bank angle of theta (0 for rectangular)
# (3) is filled with water to a depth of d.
# The units of wb and d are meters. The units of
# theta are assumed to be degrees and are converted.
# NB! wb should never be zero, so PW can never be 0,
# which would produce a NaN (divide by zero).
# See Notes for TF_Tan function in utils_TF.pro
# AW = d * (wb + (d * TF_Tan(theta_rad)) )
theta_rad = (theta * np.pi / 180.0)
AW = d * (wb + (d * np.tan(theta_rad)) )
PW = wb + (np.float64(2) * d / np.cos(theta_rad) )
Rh = (AW / PW)
w = np.where(wb <= 0)
nw = np.size(w[0])
return Rh
# Trapezoid_Rh()
def Manning_Formula(Rh, S, nval):
# Notes: R = (A/P) = hydraulic radius [m]
# N = Manning's roughness coefficient
# (usually in the range 0.012 to 0.035)
# S = bed slope (assumed equal to friction slope)
# R,S, and N may be 2D arrays.
# If length units are all *feet*, then an extra
# factor of 1.49 must be applied. If units are
# meters, no such factor is needed.
# Note that Q = Ac * u, where Ac is cross-section
# area. For a trapezoid, Ac does not equal w*d.
## if (N == None): N = np.float64(0.03)
two_thirds = np.float64(2) / 3.0
u = (Rh ** two_thirds) * np.sqrt(S) / nval
# Add a hydraulic jump option
# for when u gets too big ??
return u
# Manning_Formula()
def Law_of_the_Wall(d, Rh, S, z0val):
# Notes: u = flow velocity [m/s]
# d = flow depth [m]
# z0 = roughness height
# S = bed slope (assumed equal to friction slope)
# g = 9.81 = gravitation constant [m/s^2]
# kappa = 0.41 = von Karman's constant
# aval = 0.48 = integration constant
# sqrt(g)/kappa = 7.6393d
# smoothness = (aval / z0) * d
# f = (kappa / alog(smoothness))^2d
# tau_bed = rho_w * f * u^2 = rho_w * g * d * S
# d, S, and z0 can be arrays.
# To make default z0 correspond to default
# Manning's n, can use this approximation:
# z0 = a * (2.34 * sqrt(9.81) * n / kappa)^6d
# For n=0.03, this gives: z0 = 0.011417
# However, for n=0.3, it gives: z0 = 11417.413
# which is 11.4 km! So the approximation only
# holds within some range of values.
## if (self.z0val == None):
## self.z0val = np.float64(0.011417) # (about 1 cm)
# Define some constants
g = np.float64(9.81) # (gravitation const.)
aval = np.float64(0.476) # (integration const.)
kappa = np.float64(0.408) # (von Karman's const.)
law_const = np.sqrt(g) / kappa
smoothness = (aval / z0val) * d
# Make sure (smoothness > 1)
smoothness = np.maximum(smoothness, np.float64(1.1))
u = law_const * np.sqrt(Rh * S) * np.log(smoothness)
# Add a hydraulic jump option
# for when u gets too big ??
return u
|
#include <QDebug>
#include <net/if.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include "monitor.h"
Monitor::Monitor()
{
running = 0;
}
void Monitor::start()
{
int rc;
int s;
fd_set rdfs;
int nbytes;
struct sockaddr_can addr;
struct canfd_frame frame;
struct iovec iov;
char ctrlmsg[CMSG_SPACE(sizeof(struct timeval)) + CMSG_SPACE(sizeof(__u32))];
struct msghdr msg;
struct ifreq ifr;
char* ifname = "can0";
running = 1;
s = socket(PF_CAN, SOCK_RAW, CAN_RAW);
if (s < 0)
{
qDebug() << "Error opening socket: " << s;
stop();
return;
}
strcpy(ifr.ifr_name, ifname);
ioctl(s, SIOCGIFINDEX, &ifr);
addr.can_family = AF_CAN;
addr.can_ifindex = ifr.ifr_ifindex;
rc = bind(s, (struct sockaddr*)&addr, sizeof(addr));
if (rc < 0)
{
qDebug() << "Error binding to interface: " << rc;
stop();
return;
}
iov.iov_base = &frame;
msg.msg_name = &addr;
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = &ctrlmsg;
while (running)
{
FD_ZERO(&rdfs);
FD_SET(s, &rdfs);
rc = select(s, &rdfs, NULL, NULL, NULL);
if (rc < 0)
{
qDebug() << "Error calling select" << rc;
stop();
continue;
}
if (FD_ISSET(s, &rdfs))
{
int maxdlen;
// These can apparently get changed, so set before each read
iov.iov_len = sizeof(frame);
msg.msg_namelen = sizeof(addr);
msg.msg_controllen = sizeof(ctrlmsg);
msg.msg_flags = 0;
nbytes = recvmsg(s, &msg, 0);
if (nbytes < 0)
{
qDebug() << "Error calling recvmsg : " << nbytes;
stop();
continue;
}
if ((size_t)nbytes == CAN_MTU)
maxdlen = CAN_MAX_DLEN;
else if ((size_t)nbytes == CANFD_MTU)
maxdlen = CANFD_MAX_DLEN;
else
{
qDebug() << "Warning: read incomplete CAN frame : " << nbytes;
continue;
}
// TODO get timestamp from message
sendMsg(&frame, maxdlen);
}
}
}
void Monitor::stop()
{
running = 0;
}
void Monitor::sendMsg(struct canfd_frame *frame, int maxdlen)
{
canMessage msg;
char buf[200];
int pBuf = 0;
int i;
int len = (frame->len > maxdlen) ? maxdlen : frame->len;
msg.interface = 1; // TODO set in constructor at some point
msg.identifier = QString("%1:%03X")
.arg(msg.interface)
.arg(frame->can_id & CAN_SFF_MASK);
msg.time = QTime::currentTime();
pBuf += sprintf(buf + pBuf, "[%d]", frame->len);
if (frame->can_id & CAN_RTR_FLAG)
{
pBuf += sprintf(buf + pBuf, " remote request");
emit messageInBuffer(&msg);
return;
}
for (i = 0; i < len; i++)
{
pBuf += sprintf(buf + pBuf, " [%02X]", frame->data[i]);
}
msg.content = QString("%1").arg(buf);
emit messageInBuffer(&msg);
}
|
// <auto-generated>
// This code was generated by a tool.
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
namespace CC.Common.Compression.Demo.Properties
{
[global::System.Runtime.CompilerServices.<API key>()]
[global::System.CodeDom.Compiler.<API key>("Microsoft.VisualStudio.Editors.SettingsDesigner.<API key>", "11.0.0.0")]
internal sealed partial class Settings : global::System.Configuration.<API key>
{
private static Settings defaultInstance = ((Settings)(global::System.Configuration.<API key>.Synchronized(new Settings())));
public static Settings Default
{
get
{
return defaultInstance;
}
}
}
}
|
#include <linux/platform_device.h>
#include <linux/cdev.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/interrupt.h>
#include <linux/sched.h>
#include <linux/uaccess.h>
#include <linux/clk.h>
#include <linux/android_pmem.h>
#include <linux/msm_rotator.h>
#include <linux/io.h>
#include <mach/msm_rotator_imem.h>
#include <linux/ktime.h>
#include <linux/workqueue.h>
#include <linux/file.h>
#include <linux/major.h>
#include <linux/regulator/consumer.h>
#include <linux/msm_ion.h>
#include <linux/sync.h>
#include <linux/sw_sync.h>
#ifdef <API key>
#include <mach/msm_bus.h>
#include <mach/msm_bus_board.h>
#endif
#include <mach/msm_subsystem_map.h>
#include <mach/iommu_domains.h>
#define DRIVER_NAME "msm_rotator"
#define MSM_ROTATOR_BASE (msm_rotator_dev->io_base)
#define <API key> (MSM_ROTATOR_BASE+0x0020)
#define <API key> (MSM_ROTATOR_BASE+0x0024)
#define <API key> (MSM_ROTATOR_BASE+0x0028)
#define MSM_ROTATOR_START (MSM_ROTATOR_BASE+0x0030)
#define <API key> (MSM_ROTATOR_BASE+0x0050)
#define <API key> (MSM_ROTATOR_BASE+0x0070)
#define <API key> (MSM_ROTATOR_BASE+0x0074)
#define <API key> (MSM_ROTATOR_BASE+0x1108)
#define <API key> (MSM_ROTATOR_BASE+0x110c)
#define <API key> (MSM_ROTATOR_BASE+0x1110)
#define <API key> (MSM_ROTATOR_BASE+0x1114)
#define <API key> (MSM_ROTATOR_BASE+0x111c)
#define <API key> (MSM_ROTATOR_BASE+0x1120)
#define <API key> (MSM_ROTATOR_BASE+0x1124)
#define <API key> (MSM_ROTATOR_BASE+0x1128)
#define <API key> (MSM_ROTATOR_BASE+0x1138)
#define <API key> (MSM_ROTATOR_BASE+0x1154)
#define <API key> (MSM_ROTATOR_BASE+0x1168)
#define <API key> (MSM_ROTATOR_BASE+0x116c)
#define <API key> (MSM_ROTATOR_BASE+0x1170)
#define <API key> (MSM_ROTATOR_BASE+0x1178)
#define <API key> (MSM_ROTATOR_BASE+0x117c)
#define MSM_ROTATOR_SRC_XY (MSM_ROTATOR_BASE+0x1200)
#define <API key> (MSM_ROTATOR_BASE+0x1208)
#define MSM_ROTATOR_MAX_ROT 0x07
#define MSM_ROTATOR_MAX_H 0x1fff
#define MSM_ROTATOR_MAX_W 0x1fff
/* from lsb to msb */
#define GET_PACK_PATTERN(a, x, y, z, bit) \
(((a)<<((bit)*3))|((x)<<((bit)*2))|((y)<<(bit))|(z))
#define CLR_G 0x0
#define CLR_B 0x1
#define CLR_R 0x2
#define CLR_ALPHA 0x3
#define CLR_Y CLR_G
#define CLR_CB CLR_B
#define CLR_CR CLR_R
#define <API key>(r) ((((r) & MDP_ROT_90) ? 1 : 0) | \
(((r) & MDP_FLIP_LR) ? 2 : 0) | \
(((r) & MDP_FLIP_UD) ? 4 : 0))
#define IMEM_NO_OWNER -1;
#define MAX_SESSIONS 16
#define INVALID_SESSION -1
#define VERSION_KEY_MASK 0xFFFFFF00
#define MAX_DOWNSCALE_RATIO 3
#define MAX_COMMIT_QUEUE 4
#define WAIT_ROT_TIMEOUT 1000
#define <API key> 16
#define <API key> MSEC_PER_SEC
#define <API key> (10 * MSEC_PER_SEC)
#define ROTATOR_REVISION_V0 0
#define ROTATOR_REVISION_V1 1
#define ROTATOR_REVISION_V2 2
#define <API key> 0xffffffff
#define BASE_ADDR(height, y_stride) ((height % 64) * y_stride)
#define HW_BASE_ADDR(height, y_stride) (((dstp0_ystride >> 5) << 11) - \
((dst_height & 0x3f) * dstp0_ystride))
uint32_t rotator_hw_revision;
static char <API key>;
/*
* rotator_hw_revision:
* 0 == 7x30
* 1 == 8x60
* 2 == 8960
*
*/
struct tile_parm {
unsigned int width; /* tile's width */
unsigned int height; /* tile's height */
unsigned int row_tile_w; /* tiles per row's width */
unsigned int row_tile_h; /* tiles per row's height */
};
struct <API key> {
unsigned int num_planes;
unsigned int plane_size[4];
unsigned int total_size;
};
#define checkoffset(offset, size, max_size) \
((size) > (max_size) || (offset) > ((max_size) - (size)))
struct msm_rotator_fd_info {
int pid;
int ref_cnt;
struct list_head list;
};
struct rot_sync_info {
u32 initialized;
struct sync_fence *acq_fen;
struct sync_fence *rel_fen;
int rel_fen_fd;
struct sw_sync_timeline *timeline;
int timeline_value;
struct mutex sync_mutex;
atomic_t queue_buf_cnt;
};
struct msm_rotator_session {
struct <API key> img_info;
struct msm_rotator_fd_info fd_info;
int fast_yuv_enable;
int enable_2pass;
u32 mem_hid;
};
struct <API key> {
struct <API key> data_info;
struct <API key> img_info;
unsigned int format;
unsigned int in_paddr;
unsigned int out_paddr;
unsigned int in_chroma_paddr;
unsigned int out_chroma_paddr;
unsigned int in_chroma2_paddr;
unsigned int out_chroma2_paddr;
struct file *srcp0_file;
struct file *srcp1_file;
struct file *dstp0_file;
struct file *dstp1_file;
struct ion_handle *srcp0_ihdl;
struct ion_handle *srcp1_ihdl;
struct ion_handle *dstp0_ihdl;
struct ion_handle *dstp1_ihdl;
int ps0_need;
int session_index;
struct sync_fence *acq_fen;
int fast_yuv_en;
int enable_2pass;
};
struct msm_rotator_dev {
void __iomem *io_base;
int irq;
struct clk *core_clk;
struct msm_rotator_session *rot_session[MAX_SESSIONS];
struct list_head fd_list;
struct clk *pclk;
int rot_clk_state;
struct regulator *regulator;
struct delayed_work rot_clk_work;
struct clk *imem_clk;
int imem_clk_state;
struct delayed_work imem_clk_work;
struct platform_device *pdev;
struct cdev cdev;
struct device *device;
struct class *class;
dev_t dev_num;
int processing;
int last_session_idx;
struct mutex rotator_lock;
struct mutex imem_lock;
int imem_owner;
wait_queue_head_t wq;
struct ion_client *client;
#ifdef <API key>
uint32_t bus_client_handle;
#endif
u32 sec_mapped;
u32 mmu_clk_on;
struct rot_sync_info sync_info[MAX_SESSIONS];
/* non blocking */
struct mutex commit_mutex;
struct mutex commit_wq_mutex;
struct completion commit_comp;
u32 commit_running;
struct work_struct commit_work;
struct <API key> commit_info[MAX_COMMIT_QUEUE];
atomic_t commit_q_r;
atomic_t commit_q_w;
atomic_t commit_q_cnt;
struct rot_buf_type *y_rot_buf;
struct rot_buf_type *chroma_rot_buf;
struct rot_buf_type *chroma2_rot_buf;
};
#define COMPONENT_5BITS 1
#define COMPONENT_6BITS 2
#define COMPONENT_8BITS 3
static struct msm_rotator_dev *msm_rotator_dev;
#define mrd msm_rotator_dev
static void <API key>(u32 is_all);
enum {
CLK_EN,
CLK_DIS,
CLK_SUSPEND,
};
struct res_mmu_clk {
char *mmu_clk_name;
struct clk *mmu_clk;
};
static struct res_mmu_clk rot_mmu_clks[] = {
{"mdp_iommu_clk"}, {"rot_iommu_clk"},
{"vcodec_iommu0_clk"}, {"vcodec_iommu1_clk"},
{"smmu_iface_clk"}
};
u32 <API key>(struct rot_buf_type *rot_buf, int s_ndx)
{
ion_phys_addr_t addr, read_addr = 0;
size_t buffer_size;
unsigned long len;
if (!rot_buf) {
pr_err("Rot_buf NULL pointer %s %i", __func__, __LINE__);
return 0;
}
if (rot_buf->write_addr || !IS_ERR_OR_NULL(rot_buf->ihdl))
return 0;
buffer_size = roundup(1920 * 1088, SZ_4K);
if (!IS_ERR_OR_NULL(mrd->client)) {
pr_info("%s:%d ion based allocation\n",
__func__, __LINE__);
rot_buf->ihdl = ion_alloc(mrd->client, buffer_size, SZ_4K,
mrd->rot_session[s_ndx]->mem_hid,
mrd->rot_session[s_ndx]->mem_hid & ION_SECURE);
if (!IS_ERR_OR_NULL(rot_buf->ihdl)) {
if (<API key>) {
if (ion_map_iommu(mrd->client, rot_buf->ihdl,
ROTATOR_SRC_DOMAIN, GEN_POOL, SZ_4K,
0, &read_addr, &len, 0, 0)) {
pr_err("ion_map_iommu() read failed\n");
return -ENOMEM;
}
if (mrd->rot_session[s_ndx]->mem_hid &
ION_SECURE) {
if (ion_phys(mrd->client, rot_buf->ihdl,
&addr, (size_t *)&len)) {
pr_err(
"%s:%d: ion_phys map failed\n",
__func__, __LINE__);
return -ENOMEM;
}
} else {
if (ion_map_iommu(mrd->client,
rot_buf->ihdl, ROTATOR_DST_DOMAIN,
GEN_POOL, SZ_4K, 0, &addr, &len,
0, 0)) {
pr_err("ion_map_iommu() failed\n");
return -ENOMEM;
}
}
} else {
if (ion_map_iommu(mrd->client, rot_buf->ihdl,
ROTATOR_SRC_DOMAIN, GEN_POOL, SZ_4K,
0, &addr, &len, 0, 0)) {
pr_err("ion_map_iommu() write failed\n");
return -ENOMEM;
}
}
} else {
pr_err("%s:%d: ion_alloc failed\n", __func__,
__LINE__);
return -ENOMEM;
}
} else {
addr = <API key>(buffer_size,
mrd->rot_session[s_ndx]->mem_hid, 4);
}
if (addr) {
pr_info("allocating %d bytes at write=%x, read=%x for 2-pass\n",
buffer_size, (u32) addr, (u32) read_addr);
rot_buf->write_addr = addr;
if (read_addr)
rot_buf->read_addr = read_addr;
else
rot_buf->read_addr = rot_buf->write_addr;
return 0;
} else {
pr_err("%s cannot allocate memory for rotator 2-pass!\n",
__func__);
return -ENOMEM;
}
}
void <API key>(struct rot_buf_type *rot_buf, int s_ndx)
{
if (!rot_buf) {
pr_err("Rot_buf NULL pointer %s %i", __func__, __LINE__);
return;
}
if (!rot_buf->write_addr)
return;
if (!IS_ERR_OR_NULL(mrd->client)) {
if (!IS_ERR_OR_NULL(rot_buf->ihdl)) {
if (<API key>) {
if (!(mrd->rot_session[s_ndx]->mem_hid &
ION_SECURE))
ion_unmap_iommu(mrd->client,
rot_buf->ihdl, ROTATOR_DST_DOMAIN,
GEN_POOL);
ion_unmap_iommu(mrd->client, rot_buf->ihdl,
ROTATOR_SRC_DOMAIN, GEN_POOL);
} else {
ion_unmap_iommu(mrd->client, rot_buf->ihdl,
ROTATOR_SRC_DOMAIN, GEN_POOL);
}
ion_free(mrd->client, rot_buf->ihdl);
rot_buf->ihdl = NULL;
pr_info("%s:%d Free rotator 2pass memory",
__func__, __LINE__);
}
} else {
if (rot_buf->write_addr) {
<API key>(rot_buf->write_addr);
pr_debug("%s:%d Free rotator 2pass pmem\n", __func__,
__LINE__);
}
}
rot_buf->write_addr = 0;
rot_buf->read_addr = 0;
}
int <API key>(int mem_id, int domain,
unsigned long *start, unsigned long *len,
struct ion_handle **pihdl, unsigned int secure)
{
if (!msm_rotator_dev->client)
return -EINVAL;
*pihdl = ion_import_dma_buf(msm_rotator_dev->client, mem_id);
if (IS_ERR_OR_NULL(*pihdl)) {
pr_err("ion_import_dma_buf() failed\n");
return PTR_ERR(*pihdl);
}
pr_debug("%s(): ion_hdl %p, ion_fd %d\n", __func__, *pihdl, mem_id);
if (<API key>) {
if (secure) {
if (ion_phys(msm_rotator_dev->client,
*pihdl, start, (unsigned *)len)) {
pr_err("%s:%d: ion_phys map failed\n",
__func__, __LINE__);
return -ENOMEM;
}
} else {
if (ion_map_iommu(msm_rotator_dev->client,
*pihdl, domain, GEN_POOL,
SZ_4K, 0, start, len, 0,
<API key>)) {
pr_err("ion_map_iommu() failed\n");
return -EINVAL;
}
}
} else {
if (ion_map_iommu(msm_rotator_dev->client,
*pihdl, ROTATOR_SRC_DOMAIN, GEN_POOL,
SZ_4K, 0, start, len, 0, <API key>)) {
pr_err("ion_map_iommu() failed\n");
return -EINVAL;
}
}
pr_debug("%s(): mem_id %d, start 0x%lx, len 0x%lx\n",
__func__, mem_id, *start, *len);
return 0;
}
int <API key>(int requestor)
{
int rc = 0;
#ifdef <API key>
switch (requestor) {
case ROTATOR_REQUEST:
if (mutex_trylock(&msm_rotator_dev->imem_lock)) {
msm_rotator_dev->imem_owner = ROTATOR_REQUEST;
rc = 1;
} else
rc = 0;
break;
case JPEG_REQUEST:
mutex_lock(&msm_rotator_dev->imem_lock);
msm_rotator_dev->imem_owner = JPEG_REQUEST;
rc = 1;
break;
default:
rc = 0;
}
#else
if (requestor == JPEG_REQUEST)
rc = 1;
#endif
if (rc == 1) {
<API key>(&msm_rotator_dev->imem_clk_work);
if (msm_rotator_dev->imem_clk_state != CLK_EN
&& msm_rotator_dev->imem_clk) {
clk_prepare_enable(msm_rotator_dev->imem_clk);
msm_rotator_dev->imem_clk_state = CLK_EN;
}
}
return rc;
}
EXPORT_SYMBOL(<API key>);
void <API key>(int requestor)
{
#ifdef <API key>
if (msm_rotator_dev->imem_owner == requestor) {
<API key>(&msm_rotator_dev->imem_clk_work, HZ);
mutex_unlock(&msm_rotator_dev->imem_lock);
}
#else
if (requestor == JPEG_REQUEST)
<API key>(&msm_rotator_dev->imem_clk_work, HZ);
#endif
}
EXPORT_SYMBOL(<API key>);
static void <API key>(struct work_struct *work)
{
#ifdef <API key>
if (mutex_trylock(&msm_rotator_dev->imem_lock)) {
if (msm_rotator_dev->imem_clk_state == CLK_EN
&& msm_rotator_dev->imem_clk) {
<API key>(msm_rotator_dev->imem_clk);
msm_rotator_dev->imem_clk_state = CLK_DIS;
} else if (msm_rotator_dev->imem_clk_state == CLK_SUSPEND)
msm_rotator_dev->imem_clk_state = CLK_DIS;
mutex_unlock(&msm_rotator_dev->imem_lock);
}
#endif
}
/* enable clocks needed by rotator block */
static void enable_rot_clks(void)
{
if (msm_rotator_dev->regulator)
regulator_enable(msm_rotator_dev->regulator);
if (msm_rotator_dev->core_clk != NULL)
clk_prepare_enable(msm_rotator_dev->core_clk);
if (msm_rotator_dev->pclk != NULL)
clk_prepare_enable(msm_rotator_dev->pclk);
}
/* disable clocks needed by rotator block */
static void disable_rot_clks(void)
{
if (msm_rotator_dev->core_clk != NULL)
<API key>(msm_rotator_dev->core_clk);
if (msm_rotator_dev->pclk != NULL)
<API key>(msm_rotator_dev->pclk);
if (msm_rotator_dev->regulator)
regulator_disable(msm_rotator_dev->regulator);
}
static void <API key>(struct work_struct *work)
{
if (mutex_trylock(&msm_rotator_dev->rotator_lock)) {
if (msm_rotator_dev->rot_clk_state == CLK_EN) {
disable_rot_clks();
msm_rotator_dev->rot_clk_state = CLK_DIS;
} else if (msm_rotator_dev->rot_clk_state == CLK_SUSPEND)
msm_rotator_dev->rot_clk_state = CLK_DIS;
mutex_unlock(&msm_rotator_dev->rotator_lock);
}
}
static irqreturn_t msm_rotator_isr(int irq, void *dev_id)
{
if (msm_rotator_dev->processing) {
msm_rotator_dev->processing = 0;
wake_up(&msm_rotator_dev->wq);
} else
printk(KERN_WARNING "%s: unexpected interrupt\n", DRIVER_NAME);
return IRQ_HANDLED;
}
static void <API key>(u32 session_index)
{
struct rot_sync_info *sync_info;
sync_info = &msm_rotator_dev->sync_info[session_index];
if ((!sync_info->timeline) || (!sync_info->initialized))
return;
mutex_lock(&sync_info->sync_mutex);
<API key>(sync_info->timeline, 1);
sync_info->timeline_value++;
mutex_unlock(&sync_info->sync_mutex);
}
static void <API key>(u32 session_index)
{
struct rot_sync_info *sync_info;
sync_info = &msm_rotator_dev->sync_info[session_index];
if ((sync_info->timeline == NULL) ||
(sync_info->initialized == false))
return;
mutex_lock(&sync_info->sync_mutex);
<API key>(sync_info->timeline, 1);
sync_info->timeline_value++;
if (atomic_read(&sync_info->queue_buf_cnt) <= 0)
pr_err("%s queue_buf_cnt=%d", __func__,
atomic_read(&sync_info->queue_buf_cnt));
else
atomic_dec(&sync_info->queue_buf_cnt);
mutex_unlock(&sync_info->sync_mutex);
}
static void <API key>(u32 session_index)
{
struct rot_sync_info *sync_info;
sync_info = &msm_rotator_dev->sync_info[session_index];
if ((!sync_info->timeline) || (!sync_info->initialized))
return;
mutex_lock(&sync_info->sync_mutex);
sync_info->acq_fen = NULL;
mutex_unlock(&sync_info->sync_mutex);
}
static void <API key>(void)
{
int i;
struct rot_sync_info *sync_info;
for (i = 0; i < MAX_SESSIONS; i++) {
sync_info = &msm_rotator_dev->sync_info[i];
if (sync_info->initialized) {
<API key>(i);
<API key>(i);
}
}
}
static void <API key>(struct sync_fence *acq_fen)
{
int ret;
if (acq_fen) {
ret = sync_fence_wait(acq_fen,
<API key>);
if (ret == -ETIME) {
pr_warn("%s: timeout, wait %ld more ms\n",
__func__, <API key>);
ret = sync_fence_wait(acq_fen,
<API key>);
}
if (ret < 0) {
pr_err("%s: sync_fence_wait failed! ret = %x\n",
__func__, ret);
}
sync_fence_put(acq_fen);
}
}
static int <API key>(unsigned long arg)
{
struct <API key> buf_sync;
int ret = 0;
struct sync_fence *fence = NULL;
struct rot_sync_info *sync_info;
struct sync_pt *rel_sync_pt;
struct sync_fence *rel_fence;
int rel_fen_fd;
u32 s;
if (copy_from_user(&buf_sync, (void __user *)arg, sizeof(buf_sync)))
return -EFAULT;
<API key>(false);
for (s = 0; s < MAX_SESSIONS; s++)
if ((msm_rotator_dev->rot_session[s] != NULL) &&
(buf_sync.session_id ==
(unsigned int)msm_rotator_dev->rot_session[s]
))
break;
if (s == MAX_SESSIONS) {
pr_err("%s invalid session id %d", __func__,
buf_sync.session_id);
return -EINVAL;
}
sync_info = &msm_rotator_dev->sync_info[s];
if (sync_info->acq_fen)
pr_err("%s previous acq_fen will be overwritten", __func__);
if ((sync_info->timeline == NULL) ||
(sync_info->initialized == false))
return -EINVAL;
mutex_lock(&sync_info->sync_mutex);
if (buf_sync.acq_fen_fd >= 0)
fence = sync_fence_fdget(buf_sync.acq_fen_fd);
sync_info->acq_fen = fence;
if (sync_info->acq_fen &&
(buf_sync.flags & <API key>)) {
<API key>(sync_info->acq_fen);
sync_info->acq_fen = NULL;
}
rel_sync_pt = sw_sync_pt_create(sync_info->timeline,
sync_info->timeline_value +
atomic_read(&sync_info->queue_buf_cnt) + 1);
if (rel_sync_pt == NULL) {
pr_err("%s: cannot create sync point", __func__);
ret = -ENOMEM;
goto buf_sync_err_1;
}
/* create fence */
rel_fence = sync_fence_create("msm_rotator-fence",
rel_sync_pt);
if (rel_fence == NULL) {
sync_pt_free(rel_sync_pt);
pr_err("%s: cannot create fence", __func__);
ret = -ENOMEM;
goto buf_sync_err_1;
}
/* create fd */
rel_fen_fd = get_unused_fd_flags(0);
if (rel_fen_fd < 0) {
pr_err("%s: get_unused_fd_flags failed", __func__);
ret = -EIO;
goto buf_sync_err_2;
}
sync_fence_install(rel_fence, rel_fen_fd);
buf_sync.rel_fen_fd = rel_fen_fd;
sync_info->rel_fen = rel_fence;
sync_info->rel_fen_fd = rel_fen_fd;
ret = copy_to_user((void __user *)arg, &buf_sync, sizeof(buf_sync));
mutex_unlock(&sync_info->sync_mutex);
return ret;
buf_sync_err_2:
sync_fence_put(rel_fence);
buf_sync_err_1:
if (sync_info->acq_fen)
sync_fence_put(sync_info->acq_fen);
sync_info->acq_fen = NULL;
mutex_unlock(&sync_info->sync_mutex);
return ret;
}
static unsigned int tile_size(unsigned int src_width,
unsigned int src_height,
const struct tile_parm *tp)
{
unsigned int tile_w, tile_h;
unsigned int row_num_w, row_num_h;
tile_w = tp->width * tp->row_tile_w;
tile_h = tp->height * tp->row_tile_h;
row_num_w = (src_width + tile_w - 1) / tile_w;
row_num_h = (src_height + tile_h - 1) / tile_h;
return ((row_num_w * row_num_h * tile_w * tile_h) + 8191) & ~8191;
}
static int get_bpp(int format)
{
switch (format) {
case MDP_RGB_565:
case MDP_BGR_565:
return 2;
case MDP_XRGB_8888:
case MDP_ARGB_8888:
case MDP_RGBA_8888:
case MDP_BGRA_8888:
case MDP_RGBX_8888:
return 4;
case MDP_Y_CBCR_H2V2:
case MDP_Y_CRCB_H2V2:
case MDP_Y_CB_CR_H2V2:
case MDP_Y_CR_CB_H2V2:
case MDP_Y_CR_CB_GH2V2:
case <API key>:
case <API key>:
return 1;
case MDP_RGB_888:
case MDP_YCBCR_H1V1:
case MDP_YCRCB_H1V1:
return 3;
case MDP_YCRYCB_H2V1:
return 2;/* YCrYCb interleave */
case MDP_Y_CRCB_H2V1:
case MDP_Y_CBCR_H2V1:
return 1;
default:
return -1;
}
}
static int <API key>(uint32_t format, uint32_t w, uint32_t h,
struct <API key> *p)
{
/*
* each row of samsung tile consists of two tiles in height
* and two tiles in width which means width should align to
* 64 x 2 bytes and height should align to 32 x 2 bytes.
* video decoder generate two tiles in width and one tile
* in height which ends up height align to 32 X 1 bytes.
*/
const struct tile_parm tile = {64, 32, 2, 1};
int i;
if (p == NULL)
return -EINVAL;
if ((w > MSM_ROTATOR_MAX_W) || (h > MSM_ROTATOR_MAX_H))
return -ERANGE;
memset(p, 0, sizeof(*p));
switch (format) {
case MDP_XRGB_8888:
case MDP_ARGB_8888:
case MDP_RGBA_8888:
case MDP_BGRA_8888:
case MDP_RGBX_8888:
case MDP_RGB_888:
case MDP_RGB_565:
case MDP_BGR_565:
case MDP_YCRYCB_H2V1:
case MDP_YCBCR_H1V1:
case MDP_YCRCB_H1V1:
p->num_planes = 1;
p->plane_size[0] = w * h * get_bpp(format);
break;
case MDP_Y_CRCB_H2V1:
case MDP_Y_CBCR_H2V1:
case MDP_Y_CRCB_H1V2:
case MDP_Y_CBCR_H1V2:
p->num_planes = 2;
p->plane_size[0] = w * h;
p->plane_size[1] = w * h;
break;
case MDP_Y_CBCR_H2V2:
case MDP_Y_CRCB_H2V2:
p->num_planes = 2;
p->plane_size[0] = w * h;
p->plane_size[1] = w * h / 2;
break;
case <API key>:
case <API key>:
p->num_planes = 2;
p->plane_size[0] = tile_size(w, h, &tile);
p->plane_size[1] = tile_size(w, h/2, &tile);
break;
case MDP_Y_CB_CR_H2V2:
case MDP_Y_CR_CB_H2V2:
p->num_planes = 3;
p->plane_size[0] = w * h;
p->plane_size[1] = (w / 2) * (h / 2);
p->plane_size[2] = (w / 2) * (h / 2);
break;
case MDP_Y_CR_CB_GH2V2:
p->num_planes = 3;
p->plane_size[0] = ALIGN(w, 16) * h;
p->plane_size[1] = ALIGN(w / 2, 16) * (h / 2);
p->plane_size[2] = ALIGN(w / 2, 16) * (h / 2);
break;
default:
return -EINVAL;
}
for (i = 0; i < p->num_planes; i++)
p->total_size += p->plane_size[i];
return 0;
}
/* Checking invalid destination image size on FAST YUV for YUV420PP(NV12) with
* HW issue for rotation 90 + U/D filp + with/without flip operation
* (rotation 90 + U/D + L/R flip is rotation 270 degree option) and pix_rot
* block issue with tile line size is 4.
*
* Rotator structure is:
* if Fetch input image: W x H,
* Downscale: W` x H` = W/ScaleHor(2, 4 or 8) x H/ScaleVert(2, 4 or 8)
* Rotated output : W`` x H`` = (W` x H`) or (H` x W`) depends on "Rotation 90
* degree option"
*
* Pack: W`` x H``
*
* Rotator source ROI image width restriction is applied to W x H (case a,
* image resolution before downscaling)
*
* Packer source Image width/ height restriction are applied to W`` x H``
* (case c, image resolution after rotation)
*
* Supertile (64 x 8) and YUV (2 x 2) alignment restriction should be
* applied to the W x H (case a). Input image should be at least (2 x 2).
*
* "Support If packer source image height <= 256, multiple of 8", this
* restriction should be applied to the rotated image (W`` x H``)
*/
uint32_t <API key>(unsigned char rot_mode,
uint32_t src_width,
uint32_t dst_width,
uint32_t src_height,
uint32_t dst_height,
uint32_t dstp0_ystride,
uint32_t is_planar420)
{
uint32_t hw_limit;
hw_limit = is_planar420 ? 512 : 256;
/* checking image constaints for missing EOT event from pix_rot block */
if ((src_width > hw_limit) && ((src_width % (hw_limit / 2)) == 8))
return -EINVAL;
if (rot_mode & MDP_ROT_90) {
if ((src_height % 128) == 8)
return -EINVAL;
/* if rotation 90 degree on fast yuv
* rotator image input width has to be multiple of 8
* rotator image input height has to be multiple of 8
*/
if (((dst_width % 8) != 0) || ((dst_height % 8) != 0))
return -EINVAL;
if ((rot_mode & MDP_FLIP_UD) ||
(rot_mode & (MDP_FLIP_UD | MDP_FLIP_LR))) {
/* image constraint checking for wrong address
* generation HW issue for Y plane checking
*/
if (((dst_height % 64) != 0) &&
((dst_height / 64) >= 4)) {
/* compare golden logic for second
* tile base address generation in row
* with actual HW implementation
*/
if (BASE_ADDR(dst_height, dstp0_ystride) !=
HW_BASE_ADDR(dst_height, dstp0_ystride))
return -EINVAL;
}
if (is_planar420) {
dst_width = dst_width / 2;
dstp0_ystride = dstp0_ystride / 2;
}
dst_height = dst_height / 2;
/* image constraint checking for wrong
* address generation HW issue. for
* U/V (P) or UV (PP) plane checking
*/
if (((dst_height % 64) != 0) && ((dst_height / 64) >=
(hw_limit / 128))) {
/* compare golden logic for
* second tile base address
* generation in row with
* actual HW implementation
*/
if (BASE_ADDR(dst_height, dstp0_ystride) !=
HW_BASE_ADDR(dst_height, dstp0_ystride))
return -EINVAL;
}
}
} else {
/* if NOT applying rotation 90 degree on fast yuv,
* rotator image input width has to be multiple of 8
* rotator image input height has to be multiple of 8
*/
if (((dst_width % 8) != 0) || ((dst_height % 8) != 0))
return -EINVAL;
}
return 0;
}
static int <API key>(struct <API key> *info,
unsigned int in_paddr,
unsigned int out_paddr,
unsigned int use_imem,
int new_session,
unsigned int in_chroma_paddr,
unsigned int out_chroma_paddr)
{
int bpp;
uint32_t dst_format;
switch (info->src.format) {
case MDP_Y_CRCB_H2V1:
if (info->rotations & MDP_ROT_90)
dst_format = MDP_Y_CRCB_H1V2;
else
dst_format = info->src.format;
break;
case MDP_Y_CBCR_H2V1:
if (info->rotations & MDP_ROT_90)
dst_format = MDP_Y_CBCR_H1V2;
else
dst_format = info->src.format;
break;
default:
return -EINVAL;
}
if (info->dst.format != dst_format)
return -EINVAL;
bpp = get_bpp(info->src.format);
if (bpp < 0)
return -ENOTTY;
iowrite32(in_paddr, <API key>);
iowrite32(in_chroma_paddr, <API key>);
iowrite32(out_paddr +
((info->dst_y * info->dst.width) + info->dst_x),
<API key>);
iowrite32(out_chroma_paddr +
((info->dst_y * info->dst.width) + info->dst_x),
<API key>);
if (new_session) {
iowrite32(info->src.width |
info->src.width << 16,
<API key>);
if (info->rotations & MDP_ROT_90)
iowrite32(info->dst.width |
info->dst.width*2 << 16,
<API key>);
else
iowrite32(info->dst.width |
info->dst.width << 16,
<API key>);
if (info->src.format == MDP_Y_CBCR_H2V1) {
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CB, CLR_CR, 8),
<API key>);
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CB, CLR_CR, 8),
<API key>);
} else {
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8),
<API key>);
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8),
<API key>);
}
iowrite32((1 << 18) | /* chroma sampling 1=H2V1 */
(<API key>(info->rotations) << 9) |
1 << 8 | /* ROT_EN */
info->downscale_ratio << 2 | /* downscale v ratio */
info->downscale_ratio, /* downscale h ratio */
<API key>);
iowrite32(0 << 29 | /* frame format 0 = linear */
(use_imem ? 0 : 1) << 22 | /* tile size */
2 << 19 | /* fetch planes 2 = pseudo */
0 << 18 | /* unpack align */
1 << 17 | /* unpack tight */
1 << 13 | /* unpack count 0=1 component */
(bpp-1) << 9 | /* src Bpp 0=1 byte ... */
0 << 8 | /* has alpha */
0 << 6 | /* alpha bits 3=8bits */
3 << 4 | /* R/Cr bits 1=5 2=6 3=8 */
3 << 2 | /* B/Cb bits 1=5 2=6 3=8 */
3 << 0, /* G/Y bits 1=5 2=6 3=8 */
<API key>);
}
return 0;
}
static int <API key>(struct <API key> *info,
unsigned int in_paddr,
unsigned int out_paddr,
unsigned int use_imem,
int new_session,
unsigned int in_chroma_paddr,
unsigned int out_chroma_paddr,
unsigned int in_chroma2_paddr,
unsigned int out_chroma2_paddr,
int fast_yuv_en)
{
uint32_t dst_format;
int is_tile = 0;
switch (info->src.format) {
case <API key>:
is_tile = 1;
dst_format = MDP_Y_CRCB_H2V2;
break;
case MDP_Y_CR_CB_H2V2:
case MDP_Y_CR_CB_GH2V2:
if (fast_yuv_en) {
dst_format = info->src.format;
break;
}
case MDP_Y_CRCB_H2V2:
dst_format = MDP_Y_CRCB_H2V2;
break;
case MDP_Y_CB_CR_H2V2:
if (fast_yuv_en) {
dst_format = info->src.format;
break;
}
dst_format = MDP_Y_CBCR_H2V2;
break;
case <API key>:
is_tile = 1;
case MDP_Y_CBCR_H2V2:
dst_format = MDP_Y_CBCR_H2V2;
break;
default:
return -EINVAL;
}
if (info->dst.format != dst_format)
return -EINVAL;
/* rotator expects YCbCr for planar input format */
if ((info->src.format == MDP_Y_CR_CB_H2V2 ||
info->src.format == MDP_Y_CR_CB_GH2V2) &&
rotator_hw_revision < ROTATOR_REVISION_V2)
swap(in_chroma_paddr, in_chroma2_paddr);
iowrite32(in_paddr, <API key>);
iowrite32(in_chroma_paddr, <API key>);
iowrite32(in_chroma2_paddr, <API key>);
iowrite32(out_paddr +
((info->dst_y * info->dst.width) + info->dst_x),
<API key>);
iowrite32(out_chroma_paddr +
(((info->dst_y * info->dst.width)/2) + info->dst_x),
<API key>);
if (out_chroma2_paddr)
iowrite32(out_chroma2_paddr +
(((info->dst_y * info->dst.width)/2) + info->dst_x),
<API key>);
if (new_session) {
if (in_chroma2_paddr) {
if (info->src.format == MDP_Y_CR_CB_GH2V2) {
iowrite32(ALIGN(info->src.width, 16) |
ALIGN((info->src.width / 2), 16) << 16,
<API key>);
iowrite32(ALIGN((info->src.width / 2), 16),
<API key>);
} else {
iowrite32(info->src.width |
(info->src.width / 2) << 16,
<API key>);
iowrite32((info->src.width / 2),
<API key>);
}
} else {
iowrite32(info->src.width |
info->src.width << 16,
<API key>);
}
if (out_chroma2_paddr) {
if (info->dst.format == MDP_Y_CR_CB_GH2V2) {
iowrite32(ALIGN(info->dst.width, 16) |
ALIGN((info->dst.width / 2), 16) << 16,
<API key>);
iowrite32(ALIGN((info->dst.width / 2), 16),
<API key>);
} else {
iowrite32(info->dst.width |
info->dst.width/2 << 16,
<API key>);
iowrite32(info->dst.width/2,
<API key>);
}
} else {
iowrite32(info->dst.width |
info->dst.width << 16,
<API key>);
}
if (dst_format == MDP_Y_CBCR_H2V2 ||
dst_format == MDP_Y_CB_CR_H2V2) {
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CB, CLR_CR, 8),
<API key>);
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CB, CLR_CR, 8),
<API key>);
} else {
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8),
<API key>);
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8),
<API key>);
}
iowrite32((3 << 18) | /* chroma sampling 3=4:2:0 */
(<API key>(info->rotations) << 9) |
1 << 8 | /* ROT_EN */
fast_yuv_en << 4 | /*fast YUV*/
info->downscale_ratio << 2 | /* downscale v ratio */
info->downscale_ratio, /* downscale h ratio */
<API key>);
iowrite32((is_tile ? 2 : 0) << 29 | /* frame format */
(use_imem ? 0 : 1) << 22 | /* tile size */
(in_chroma2_paddr ? 1 : 2) << 19 | /* fetch planes */
0 << 18 | /* unpack align */
1 << 17 | /* unpack tight */
1 << 13 | /* unpack count 0=1 component */
0 << 9 | /* src Bpp 0=1 byte ... */
0 << 8 | /* has alpha */
0 << 6 | /* alpha bits 3=8bits */
3 << 4 | /* R/Cr bits 1=5 2=6 3=8 */
3 << 2 | /* B/Cb bits 1=5 2=6 3=8 */
3 << 0, /* G/Y bits 1=5 2=6 3=8 */
<API key>);
}
return 0;
}
static int <API key>(struct <API key> *info,
unsigned int in_paddr,
unsigned int out_paddr,
unsigned int use_imem,
int new_session,
unsigned int in_chroma_paddr,
unsigned int out_chroma_paddr,
unsigned int in_chroma2_paddr,
unsigned int out_chroma2_paddr,
int fast_yuv_en,
int enable_2pass,
int session_index)
{
uint32_t pass2_src_format, pass1_dst_format, dst_format;
int is_tile = 0, <API key> = 0;
unsigned int status;
int post_pass1_ystride = info->src_rect.w >> info->downscale_ratio;
int post_pass1_height = info->src_rect.h >> info->downscale_ratio;
/* DST format = SRC format for non-tiled SRC formats
* when fast YUV is enabled. For TILED formats,
* DST format of <API key> = MDP_Y_CRCB_H2V2
* DST format of <API key> = MDP_Y_CBCR_H2V2
*/
switch (info->src.format) {
case <API key>:
is_tile = 1;
dst_format = MDP_Y_CRCB_H2V2;
pass1_dst_format = MDP_Y_CRCB_H2V2;
pass2_src_format = pass1_dst_format;
break;
case MDP_Y_CR_CB_H2V2:
case MDP_Y_CR_CB_GH2V2:
case MDP_Y_CB_CR_H2V2:
<API key> = 1;
case MDP_Y_CRCB_H2V2:
case MDP_Y_CBCR_H2V2:
dst_format = info->src.format;
pass1_dst_format = info->src.format;
pass2_src_format = pass1_dst_format;
break;
case <API key>:
is_tile = 1;
dst_format = MDP_Y_CBCR_H2V2;
pass1_dst_format = info->src.format;
pass2_src_format = pass1_dst_format;
break;
default:
return -EINVAL;
}
if (info->dst.format != dst_format)
return -EINVAL;
/* Beginning of Pass-1 */
/* rotator expects YCbCr for planar input format */
if ((info->src.format == MDP_Y_CR_CB_H2V2 ||
info->src.format == MDP_Y_CR_CB_GH2V2) &&
rotator_hw_revision < ROTATOR_REVISION_V2)
swap(in_chroma_paddr, in_chroma2_paddr);
iowrite32(in_paddr, <API key>);
iowrite32(in_chroma_paddr, <API key>);
iowrite32(in_chroma2_paddr, <API key>);
if (new_session) {
if (in_chroma2_paddr) {
if (info->src.format == MDP_Y_CR_CB_GH2V2) {
iowrite32(ALIGN(info->src.width, 16) |
ALIGN((info->src.width / 2), 16) << 16,
<API key>);
iowrite32(ALIGN((info->src.width / 2), 16),
<API key>);
} else {
iowrite32(info->src.width |
(info->src.width / 2) << 16,
<API key>);
iowrite32((info->src.width / 2),
<API key>);
}
} else {
iowrite32(info->src.width |
info->src.width << 16,
<API key>);
}
}
pr_debug("src_rect.w=%i src_rect.h=%i src_rect.x=%i src_rect.y=%i",
info->src_rect.w, info->src_rect.h, info->src_rect.x,
info->src_rect.y);
pr_debug("src.width=%i src.height=%i src_format=%i",
info->src.width, info->src.height, info->src.format);
pr_debug("dst_width=%i dst_height=%i dst.x=%i dst.y=%i",
info->dst.width, info->dst.height, info->dst_x, info->dst_y);
pr_debug("post_pass1_ystride=%i post_pass1_height=%i downscale=%i",
post_pass1_ystride, post_pass1_height, info->downscale_ratio);
<API key>(mrd->y_rot_buf, session_index);
<API key>(mrd->chroma_rot_buf, session_index);
if (<API key>)
<API key>(mrd->chroma2_rot_buf, session_index);
iowrite32(mrd->y_rot_buf->write_addr, <API key>);
iowrite32(mrd->chroma_rot_buf->write_addr, <API key>);
if (<API key>)
iowrite32(mrd->chroma2_rot_buf->write_addr,
<API key>);
if (<API key>) {
if (pass1_dst_format == MDP_Y_CR_CB_GH2V2) {
iowrite32(ALIGN(post_pass1_ystride, 16) |
ALIGN((post_pass1_ystride / 2), 16) << 16,
<API key>);
iowrite32(ALIGN((post_pass1_ystride / 2), 16),
<API key>);
} else {
iowrite32(post_pass1_ystride |
post_pass1_ystride / 2 << 16,
<API key>);
iowrite32(post_pass1_ystride / 2,
<API key>);
}
} else {
iowrite32(post_pass1_ystride |
post_pass1_ystride << 16,
<API key>);
}
if (pass1_dst_format == MDP_Y_CBCR_H2V2 ||
pass1_dst_format == MDP_Y_CB_CR_H2V2) {
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CB, CLR_CR, 8),
<API key>);
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CB, CLR_CR, 8),
<API key>);
} else {
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8),
<API key>);
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8),
<API key>);
}
iowrite32((3 << 18) | /* chroma sampling 3=4:2:0 */
0 << 9 | /* Pass-1 No Rotation */
1 << 8 | /* ROT_EN */
fast_yuv_en << 4 | /*fast YUV*/
info->downscale_ratio << 2 | /* downscale v ratio */
info->downscale_ratio, /* downscale h ratio */
<API key>);
iowrite32((is_tile ? 2 : 0) << 29 | /* frame format */
(use_imem ? 0 : 1) << 22 | /* tile size */
(in_chroma2_paddr ? 1 : 2) << 19 | /* fetch planes */
0 << 18 | /* unpack align */
1 << 17 | /* unpack tight */
1 << 13 | /* unpack count 0=1 component */
0 << 9 | /* src Bpp 0=1 byte ... */
0 << 8 | /* has alpha */
0 << 6 | /* alpha bits 3=8bits */
3 << 4 | /* R/Cr bits 1=5 2=6 3=8 */
3 << 2 | /* B/Cb bits 1=5 2=6 3=8 */
3 << 0, /* G/Y bits 1=5 2=6 3=8 */
<API key>);
iowrite32(3, <API key>);
msm_rotator_dev->processing = 1;
iowrite32(0x1, MSM_ROTATOR_START);
/* End of Pass-1 */
wait_event(msm_rotator_dev->wq,
(msm_rotator_dev->processing == 0));
/* Beginning of Pass-2 */
status = (unsigned char)ioread32(<API key>);
if ((status & 0x03) != 0x01) {
pr_err("%s(): AXI Bus Error, issuing SW_RESET\n",
__func__);
iowrite32(0x1, <API key>);
}
iowrite32(0, <API key>);
iowrite32(3, <API key>);
if (use_imem)
iowrite32(0x42, <API key>);
iowrite32(((post_pass1_height & 0x1fff)
<< 16) |
(post_pass1_ystride & 0x1fff),
<API key>);
iowrite32(0 << 16 | 0,
MSM_ROTATOR_SRC_XY);
iowrite32(((post_pass1_height & 0x1fff)
<< 16) |
(post_pass1_ystride & 0x1fff),
<API key>);
/* rotator expects YCbCr for planar input format */
if ((pass2_src_format == MDP_Y_CR_CB_H2V2 ||
pass2_src_format == MDP_Y_CR_CB_GH2V2) &&
rotator_hw_revision < ROTATOR_REVISION_V2)
swap(mrd->chroma_rot_buf->read_addr,
mrd->chroma2_rot_buf->read_addr);
iowrite32(mrd->y_rot_buf->read_addr, <API key>);
iowrite32(mrd->chroma_rot_buf->read_addr,
<API key>);
if (mrd->chroma2_rot_buf->read_addr)
iowrite32(mrd->chroma2_rot_buf->read_addr,
<API key>);
if (<API key>) {
if (pass2_src_format == MDP_Y_CR_CB_GH2V2) {
iowrite32(ALIGN(post_pass1_ystride, 16) |
ALIGN((post_pass1_ystride / 2), 16) << 16,
<API key>);
iowrite32(ALIGN((post_pass1_ystride / 2), 16),
<API key>);
} else {
iowrite32(post_pass1_ystride |
(post_pass1_ystride / 2) << 16,
<API key>);
iowrite32((post_pass1_ystride / 2),
<API key>);
}
} else {
iowrite32(post_pass1_ystride |
post_pass1_ystride << 16,
<API key>);
}
iowrite32(out_paddr +
((info->dst_y * info->dst.width) + info->dst_x),
<API key>);
iowrite32(out_chroma_paddr +
(((info->dst_y * info->dst.width)/2) + info->dst_x),
<API key>);
if (out_chroma2_paddr)
iowrite32(out_chroma2_paddr +
(((info->dst_y * info->dst.width)/2) + info->dst_x),
<API key>);
if (new_session) {
if (out_chroma2_paddr) {
if (info->dst.format == MDP_Y_CR_CB_GH2V2) {
iowrite32(ALIGN(info->dst.width, 16) |
ALIGN((info->dst.width / 2), 16) << 16,
<API key>);
iowrite32(ALIGN((info->dst.width / 2), 16),
<API key>);
} else {
iowrite32(info->dst.width |
info->dst.width/2 << 16,
<API key>);
iowrite32(info->dst.width/2,
<API key>);
}
} else {
iowrite32(info->dst.width |
info->dst.width << 16,
<API key>);
}
if (dst_format == MDP_Y_CBCR_H2V2 ||
dst_format == MDP_Y_CB_CR_H2V2) {
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CB, CLR_CR, 8),
<API key>);
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CB, CLR_CR, 8),
<API key>);
} else {
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8),
<API key>);
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8),
<API key>);
}
iowrite32((3 << 18) | /* chroma sampling 3=4:2:0 */
(<API key>(info->rotations) << 9) |
1 << 8 | /* ROT_EN */
fast_yuv_en << 4 | /*fast YUV*/
0 << 2 | /* No downscale in Pass-2 */
0, /* No downscale in Pass-2 */
<API key>);
iowrite32(0 << 29 |
/* Output of Pass-1 will always be non-tiled */
(use_imem ? 0 : 1) << 22 | /* tile size */
(in_chroma2_paddr ? 1 : 2) << 19 | /* fetch planes */
0 << 18 | /* unpack align */
1 << 17 | /* unpack tight */
1 << 13 | /* unpack count 0=1 component */
0 << 9 | /* src Bpp 0=1 byte ... */
0 << 8 | /* has alpha */
0 << 6 | /* alpha bits 3=8bits */
3 << 4 | /* R/Cr bits 1=5 2=6 3=8 */
3 << 2 | /* B/Cb bits 1=5 2=6 3=8 */
3 << 0, /* G/Y bits 1=5 2=6 3=8 */
<API key>);
}
return 0;
}
static int msm_rotator_ycrycb(struct <API key> *info,
unsigned int in_paddr,
unsigned int out_paddr,
unsigned int use_imem,
int new_session,
unsigned int out_chroma_paddr)
{
int bpp;
uint32_t dst_format;
if (info->src.format == MDP_YCRYCB_H2V1) {
if (info->rotations & MDP_ROT_90)
dst_format = MDP_Y_CRCB_H1V2;
else
dst_format = MDP_Y_CRCB_H2V1;
} else
return -EINVAL;
if (info->dst.format != dst_format)
return -EINVAL;
bpp = get_bpp(info->src.format);
if (bpp < 0)
return -ENOTTY;
iowrite32(in_paddr, <API key>);
iowrite32(out_paddr +
((info->dst_y * info->dst.width) + info->dst_x),
<API key>);
iowrite32(out_chroma_paddr +
((info->dst_y * info->dst.width)/2 + info->dst_x),
<API key>);
if (new_session) {
iowrite32(info->src.width * bpp,
<API key>);
if (info->rotations & MDP_ROT_90)
iowrite32(info->dst.width |
(info->dst.width*2) << 16,
<API key>);
else
iowrite32(info->dst.width |
(info->dst.width) << 16,
<API key>);
iowrite32(GET_PACK_PATTERN(CLR_Y, CLR_CR, CLR_Y, CLR_CB, 8),
<API key>);
iowrite32(GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8),
<API key>);
iowrite32((1 << 18) | /* chroma sampling 1=H2V1 */
(<API key>(info->rotations) << 9) |
1 << 8 | /* ROT_EN */
info->downscale_ratio << 2 | /* downscale v ratio */
info->downscale_ratio, /* downscale h ratio */
<API key>);
iowrite32(0 << 29 | /* frame format 0 = linear */
(use_imem ? 0 : 1) << 22 | /* tile size */
0 << 19 | /* fetch planes 0=interleaved */
0 << 18 | /* unpack align */
1 << 17 | /* unpack tight */
3 << 13 | /* unpack count 0=1 component */
(bpp-1) << 9 | /* src Bpp 0=1 byte ... */
0 << 8 | /* has alpha */
0 << 6 | /* alpha bits 3=8bits */
3 << 4 | /* R/Cr bits 1=5 2=6 3=8 */
3 << 2 | /* B/Cb bits 1=5 2=6 3=8 */
3 << 0, /* G/Y bits 1=5 2=6 3=8 */
<API key>);
}
return 0;
}
static int <API key>(struct <API key> *info,
unsigned int in_paddr,
unsigned int out_paddr,
unsigned int use_imem,
int new_session)
{
int bpp, abits, rbits, gbits, bbits;
if (info->src.format != info->dst.format)
return -EINVAL;
bpp = get_bpp(info->src.format);
if (bpp < 0)
return -ENOTTY;
iowrite32(in_paddr, <API key>);
iowrite32(out_paddr +
((info->dst_y * info->dst.width) + info->dst_x) * bpp,
<API key>);
if (new_session) {
iowrite32(info->src.width * bpp, <API key>);
iowrite32(info->dst.width * bpp, <API key>);
iowrite32((0 << 18) | /* chroma sampling 0=rgb */
(<API key>(info->rotations) << 9) |
1 << 8 | /* ROT_EN */
info->downscale_ratio << 2 | /* downscale v ratio */
info->downscale_ratio, /* downscale h ratio */
<API key>);
switch (info->src.format) {
case MDP_RGB_565:
iowrite32(GET_PACK_PATTERN(0, CLR_R, CLR_G, CLR_B, 8),
<API key>);
iowrite32(GET_PACK_PATTERN(0, CLR_R, CLR_G, CLR_B, 8),
<API key>);
abits = 0;
rbits = COMPONENT_5BITS;
gbits = COMPONENT_6BITS;
bbits = COMPONENT_5BITS;
break;
case MDP_BGR_565:
iowrite32(GET_PACK_PATTERN(0, CLR_B, CLR_G, CLR_R, 8),
<API key>);
iowrite32(GET_PACK_PATTERN(0, CLR_B, CLR_G, CLR_R, 8),
<API key>);
abits = 0;
rbits = COMPONENT_5BITS;
gbits = COMPONENT_6BITS;
bbits = COMPONENT_5BITS;
break;
case MDP_RGB_888:
case MDP_YCBCR_H1V1:
case MDP_YCRCB_H1V1:
iowrite32(GET_PACK_PATTERN(0, CLR_R, CLR_G, CLR_B, 8),
<API key>);
iowrite32(GET_PACK_PATTERN(0, CLR_R, CLR_G, CLR_B, 8),
<API key>);
abits = 0;
rbits = COMPONENT_8BITS;
gbits = COMPONENT_8BITS;
bbits = COMPONENT_8BITS;
break;
case MDP_ARGB_8888:
case MDP_RGBA_8888:
case MDP_XRGB_8888:
case MDP_RGBX_8888:
iowrite32(GET_PACK_PATTERN(CLR_ALPHA, CLR_R, CLR_G,
CLR_B, 8),
<API key>);
iowrite32(GET_PACK_PATTERN(CLR_ALPHA, CLR_R, CLR_G,
CLR_B, 8),
<API key>);
abits = COMPONENT_8BITS;
rbits = COMPONENT_8BITS;
gbits = COMPONENT_8BITS;
bbits = COMPONENT_8BITS;
break;
case MDP_BGRA_8888:
iowrite32(GET_PACK_PATTERN(CLR_ALPHA, CLR_B, CLR_G,
CLR_R, 8),
<API key>);
iowrite32(GET_PACK_PATTERN(CLR_ALPHA, CLR_B, CLR_G,
CLR_R, 8),
<API key>);
abits = COMPONENT_8BITS;
rbits = COMPONENT_8BITS;
gbits = COMPONENT_8BITS;
bbits = COMPONENT_8BITS;
break;
default:
return -EINVAL;
}
iowrite32(0 << 29 | /* frame format 0 = linear */
(use_imem ? 0 : 1) << 22 | /* tile size */
0 << 19 | /* fetch planes 0=interleaved */
0 << 18 | /* unpack align */
1 << 17 | /* unpack tight */
(abits ? 3 : 2) << 13 | /* unpack count 0=1 comp */
(bpp-1) << 9 | /* src Bpp 0=1 byte ... */
(abits ? 1 : 0) << 8 | /* has alpha */
abits << 6 | /* alpha bits 3=8bits */
rbits << 4 | /* R/Cr bits 1=5 2=6 3=8 */
bbits << 2 | /* B/Cb bits 1=5 2=6 3=8 */
gbits << 0, /* G/Y bits 1=5 2=6 3=8 */
<API key>);
}
return 0;
}
static int get_img(struct msmfb_data *fbd, int domain,
unsigned long *start, unsigned long *len, struct file **p_file,
int *p_need, struct ion_handle **p_ihdl, unsigned int secure)
{
int ret = 0;
#ifdef CONFIG_FB
struct file *file = NULL;
int put_needed, fb_num;
#endif
#ifdef CONFIG_ANDROID_PMEM
unsigned long vstart;
#endif
*p_need = 0;
#ifdef CONFIG_FB
if (fbd->flags & <API key>) {
file = fget_light(fbd->memory_id, &put_needed);
if (file == NULL) {
pr_err("fget_light returned NULL\n");
return -EINVAL;
}
if (MAJOR(file->f_dentry->d_inode->i_rdev) == FB_MAJOR) {
fb_num = MINOR(file->f_dentry->d_inode->i_rdev);
if (get_fb_phys_info(start, len, fb_num,
<API key>)) {
pr_err("get_fb_phys_info() failed\n");
ret = -1;
} else {
*p_file = file;
*p_need = put_needed;
}
} else {
pr_err("invalid FB_MAJOR failed\n");
ret = -1;
}
if (ret)
fput_light(file, put_needed);
return ret;
}
#endif
#ifdef <API key>
return <API key>(fbd->memory_id, domain, start,
len, p_ihdl, secure);
#endif
#ifdef CONFIG_ANDROID_PMEM
if (!get_pmem_file(fbd->memory_id, start, &vstart, len, p_file))
return 0;
else
return -ENOMEM;
#endif
}
static void put_img(struct file *p_file, struct ion_handle *p_ihdl,
int domain, unsigned int secure)
{
#ifdef CONFIG_ANDROID_PMEM
if (p_file != NULL)
put_pmem_file(p_file);
#endif
#ifdef <API key>
if (!IS_ERR_OR_NULL(p_ihdl)) {
pr_debug("%s(): p_ihdl %p\n", __func__, p_ihdl);
if (<API key>) {
if (!secure)
ion_unmap_iommu(msm_rotator_dev->client,
p_ihdl, domain, GEN_POOL);
} else {
ion_unmap_iommu(msm_rotator_dev->client,
p_ihdl, ROTATOR_SRC_DOMAIN, GEN_POOL);
}
ion_free(msm_rotator_dev->client, p_ihdl);
}
#endif
}
static int <API key>(
struct <API key> *data_info,
struct <API key> *commit_info)
{
unsigned int format;
struct <API key> info;
unsigned int in_paddr, out_paddr;
unsigned long src_len, dst_len;
int rc = 0, s;
struct file *srcp0_file = NULL, *dstp0_file = NULL;
struct file *srcp1_file = NULL, *dstp1_file = NULL;
struct ion_handle *srcp0_ihdl = NULL, *dstp0_ihdl = NULL;
struct ion_handle *srcp1_ihdl = NULL, *dstp1_ihdl = NULL;
int ps0_need, p_need;
unsigned int in_chroma_paddr = 0, out_chroma_paddr = 0;
unsigned int in_chroma2_paddr = 0, out_chroma2_paddr = 0;
struct <API key> *img_info;
struct <API key> src_planes, dst_planes;
mutex_lock(&msm_rotator_dev->rotator_lock);
info = *data_info;
for (s = 0; s < MAX_SESSIONS; s++)
if ((msm_rotator_dev->rot_session[s] != NULL) &&
(info.session_id ==
(unsigned int)msm_rotator_dev->rot_session[s]
))
break;
if (s == MAX_SESSIONS) {
pr_err("%s() : Attempt to use invalid session_id %d\n",
__func__, s);
rc = -EINVAL;
mutex_unlock(&msm_rotator_dev->rotator_lock);
return rc;
}
img_info = &(msm_rotator_dev->rot_session[s]->img_info);
if (img_info->enable == 0) {
dev_dbg(msm_rotator_dev->device,
"%s() : Session_id %d not enabled\n", __func__, s);
rc = -EINVAL;
mutex_unlock(&msm_rotator_dev->rotator_lock);
return rc;
}
if (<API key>(img_info->src.format,
img_info->src.width,
img_info->src.height,
&src_planes)) {
pr_err("%s: invalid src format\n", __func__);
rc = -EINVAL;
mutex_unlock(&msm_rotator_dev->rotator_lock);
return rc;
}
if (<API key>(img_info->dst.format,
img_info->dst.width,
img_info->dst.height,
&dst_planes)) {
pr_err("%s: invalid dst format\n", __func__);
rc = -EINVAL;
mutex_unlock(&msm_rotator_dev->rotator_lock);
return rc;
}
rc = get_img(&info.src, ROTATOR_SRC_DOMAIN, (unsigned long *)&in_paddr,
(unsigned long *)&src_len, &srcp0_file, &ps0_need,
&srcp0_ihdl, 0);
if (rc) {
pr_err("%s: in get_img() failed id=0x%08x\n",
DRIVER_NAME, info.src.memory_id);
goto <API key>;
}
rc = get_img(&info.dst, ROTATOR_DST_DOMAIN, (unsigned long *)&out_paddr,
(unsigned long *)&dst_len, &dstp0_file, &p_need,
&dstp0_ihdl, img_info->secure);
if (rc) {
pr_err("%s: out get_img() failed id=0x%08x\n",
DRIVER_NAME, info.dst.memory_id);
goto <API key>;
}
format = img_info->src.format;
if (((info.version_key & VERSION_KEY_MASK) == 0xA5B4C300) &&
((info.version_key & ~VERSION_KEY_MASK) > 0) &&
(src_planes.num_planes == 2)) {
if (checkoffset(info.src.offset,
src_planes.plane_size[0],
src_len)) {
pr_err("%s: invalid src buffer (len=%lu offset=%x)\n",
__func__, src_len, info.src.offset);
rc = -ERANGE;
goto <API key>;
}
if (checkoffset(info.dst.offset,
dst_planes.plane_size[0],
dst_len)) {
pr_err("%s: invalid dst buffer (len=%lu offset=%x)\n",
__func__, dst_len, info.dst.offset);
rc = -ERANGE;
goto <API key>;
}
rc = get_img(&info.src_chroma, ROTATOR_SRC_DOMAIN,
(unsigned long *)&in_chroma_paddr,
(unsigned long *)&src_len, &srcp1_file, &p_need,
&srcp1_ihdl, 0);
if (rc) {
pr_err("%s: in chroma get_img() failed id=0x%08x\n",
DRIVER_NAME, info.src_chroma.memory_id);
goto <API key>;
}
rc = get_img(&info.dst_chroma, ROTATOR_DST_DOMAIN,
(unsigned long *)&out_chroma_paddr,
(unsigned long *)&dst_len, &dstp1_file, &p_need,
&dstp1_ihdl, img_info->secure);
if (rc) {
pr_err("%s: out chroma get_img() failed id=0x%08x\n",
DRIVER_NAME, info.dst_chroma.memory_id);
goto <API key>;
}
if (checkoffset(info.src_chroma.offset,
src_planes.plane_size[1],
src_len)) {
pr_err("%s: invalid chr src buf len=%lu offset=%x\n",
__func__, src_len, info.src_chroma.offset);
rc = -ERANGE;
goto <API key>;
}
if (checkoffset(info.dst_chroma.offset,
src_planes.plane_size[1],
dst_len)) {
pr_err("%s: invalid chr dst buf len=%lu offset=%x\n",
__func__, dst_len, info.dst_chroma.offset);
rc = -ERANGE;
goto <API key>;
}
in_chroma_paddr += info.src_chroma.offset;
out_chroma_paddr += info.dst_chroma.offset;
} else {
if (checkoffset(info.src.offset,
src_planes.total_size,
src_len)) {
pr_err("%s: invalid src buffer (len=%lu offset=%x)\n",
__func__, src_len, info.src.offset);
rc = -ERANGE;
goto <API key>;
}
if (checkoffset(info.dst.offset,
dst_planes.total_size,
dst_len)) {
pr_err("%s: invalid dst buffer (len=%lu offset=%x)\n",
__func__, dst_len, info.dst.offset);
rc = -ERANGE;
goto <API key>;
}
}
in_paddr += info.src.offset;
out_paddr += info.dst.offset;
if (!in_chroma_paddr && src_planes.num_planes >= 2)
in_chroma_paddr = in_paddr + src_planes.plane_size[0];
if (!out_chroma_paddr && dst_planes.num_planes >= 2)
out_chroma_paddr = out_paddr + dst_planes.plane_size[0];
if (src_planes.num_planes >= 3)
in_chroma2_paddr = in_chroma_paddr + src_planes.plane_size[1];
if (dst_planes.num_planes >= 3)
out_chroma2_paddr = out_chroma_paddr + dst_planes.plane_size[1];
commit_info->data_info = info;
commit_info->img_info = *img_info;
commit_info->format = format;
commit_info->in_paddr = in_paddr;
commit_info->out_paddr = out_paddr;
commit_info->in_chroma_paddr = in_chroma_paddr;
commit_info->out_chroma_paddr = out_chroma_paddr;
commit_info->in_chroma2_paddr = in_chroma2_paddr;
commit_info->out_chroma2_paddr = out_chroma2_paddr;
commit_info->srcp0_file = srcp0_file;
commit_info->srcp1_file = srcp1_file;
commit_info->srcp0_ihdl = srcp0_ihdl;
commit_info->srcp1_ihdl = srcp1_ihdl;
commit_info->dstp0_file = dstp0_file;
commit_info->dstp0_ihdl = dstp0_ihdl;
commit_info->dstp1_file = dstp1_file;
commit_info->dstp1_ihdl = dstp1_ihdl;
commit_info->ps0_need = ps0_need;
commit_info->session_index = s;
commit_info->acq_fen = msm_rotator_dev->sync_info[s].acq_fen;
commit_info->fast_yuv_en = mrd->rot_session[s]->fast_yuv_enable;
commit_info->enable_2pass = mrd->rot_session[s]->enable_2pass;
mutex_unlock(&msm_rotator_dev->rotator_lock);
return 0;
<API key>:
put_img(dstp1_file, dstp1_ihdl, ROTATOR_DST_DOMAIN,
msm_rotator_dev->rot_session[s]->img_info.secure);
put_img(srcp1_file, srcp1_ihdl, ROTATOR_SRC_DOMAIN, 0);
put_img(dstp0_file, dstp0_ihdl, ROTATOR_DST_DOMAIN,
msm_rotator_dev->rot_session[s]->img_info.secure);
/* only source may use frame buffer */
if (info.src.flags & <API key>)
fput_light(srcp0_file, ps0_need);
else
put_img(srcp0_file, srcp0_ihdl, ROTATOR_SRC_DOMAIN, 0);
dev_dbg(msm_rotator_dev->device, "%s() returning rc = %d\n",
__func__, rc);
mutex_unlock(&msm_rotator_dev->rotator_lock);
return rc;
}
static int <API key>(
struct <API key> *commit_info)
{
unsigned int status, format;
struct <API key> info;
unsigned int in_paddr, out_paddr;
int use_imem = 0, rc = 0;
struct file *srcp0_file, *dstp0_file;
struct file *srcp1_file, *dstp1_file;
struct ion_handle *srcp0_ihdl, *dstp0_ihdl;
struct ion_handle *srcp1_ihdl, *dstp1_ihdl;
int s, ps0_need;
unsigned int in_chroma_paddr, out_chroma_paddr;
unsigned int in_chroma2_paddr, out_chroma2_paddr;
struct <API key> *img_info;
mutex_lock(&msm_rotator_dev->rotator_lock);
info = commit_info->data_info;
img_info = &commit_info->img_info;
format = commit_info->format;
in_paddr = commit_info->in_paddr;
out_paddr = commit_info->out_paddr;
in_chroma_paddr = commit_info->in_chroma_paddr;
out_chroma_paddr = commit_info->out_chroma_paddr;
in_chroma2_paddr = commit_info->in_chroma2_paddr;
out_chroma2_paddr = commit_info->out_chroma2_paddr;
srcp0_file = commit_info->srcp0_file;
srcp1_file = commit_info->srcp1_file;
srcp0_ihdl = commit_info->srcp0_ihdl;
srcp1_ihdl = commit_info->srcp1_ihdl;
dstp0_file = commit_info->dstp0_file;
dstp0_ihdl = commit_info->dstp0_ihdl;
dstp1_file = commit_info->dstp1_file;
dstp1_ihdl = commit_info->dstp1_ihdl;
ps0_need = commit_info->ps0_need;
s = commit_info->session_index;
<API key>(commit_info->acq_fen);
commit_info->acq_fen = NULL;
<API key>(&msm_rotator_dev->rot_clk_work);
if (msm_rotator_dev->rot_clk_state != CLK_EN) {
enable_rot_clks();
msm_rotator_dev->rot_clk_state = CLK_EN;
}
enable_irq(msm_rotator_dev->irq);
#ifdef <API key>
use_imem = <API key>(ROTATOR_REQUEST);
#else
use_imem = 0;
#endif
/*
* workaround for a hardware bug. rotator hardware hangs when we
* use write burst beat size 16 on 128X128 tile fetch mode. As a
* temporary fix use 0x42 for BURST_SIZE when imem used.
*/
if (use_imem)
iowrite32(0x42, <API key>);
iowrite32(((img_info->src_rect.h & 0x1fff)
<< 16) |
(img_info->src_rect.w & 0x1fff),
<API key>);
iowrite32(((img_info->src_rect.y & 0x1fff)
<< 16) |
(img_info->src_rect.x & 0x1fff),
MSM_ROTATOR_SRC_XY);
iowrite32(((img_info->src.height & 0x1fff)
<< 16) |
(img_info->src.width & 0x1fff),
<API key>);
switch (format) {
case MDP_RGB_565:
case MDP_BGR_565:
case MDP_RGB_888:
case MDP_ARGB_8888:
case MDP_RGBA_8888:
case MDP_XRGB_8888:
case MDP_BGRA_8888:
case MDP_RGBX_8888:
case MDP_YCBCR_H1V1:
case MDP_YCRCB_H1V1:
rc = <API key>(img_info,
in_paddr, out_paddr,
use_imem,
msm_rotator_dev->last_session_idx
!= s);
break;
case MDP_Y_CBCR_H2V2:
case MDP_Y_CRCB_H2V2:
case MDP_Y_CB_CR_H2V2:
case MDP_Y_CR_CB_H2V2:
case MDP_Y_CR_CB_GH2V2:
case <API key>:
case <API key>:
if (!commit_info->enable_2pass)
rc = <API key>(img_info,
in_paddr, out_paddr, use_imem,
msm_rotator_dev->last_session_idx
!= s,
in_chroma_paddr,
out_chroma_paddr,
in_chroma2_paddr,
out_chroma2_paddr,
commit_info->fast_yuv_en);
else
rc = <API key>(img_info,
in_paddr, out_paddr, use_imem,
msm_rotator_dev->last_session_idx
!= s,
in_chroma_paddr,
out_chroma_paddr,
in_chroma2_paddr,
out_chroma2_paddr,
commit_info->fast_yuv_en,
commit_info->enable_2pass,
s);
break;
case MDP_Y_CBCR_H2V1:
case MDP_Y_CRCB_H2V1:
rc = <API key>(img_info,
in_paddr, out_paddr, use_imem,
msm_rotator_dev->last_session_idx
!= s,
in_chroma_paddr,
out_chroma_paddr);
break;
case MDP_YCRYCB_H2V1:
rc = msm_rotator_ycrycb(img_info,
in_paddr, out_paddr, use_imem,
msm_rotator_dev->last_session_idx != s,
out_chroma_paddr);
break;
default:
rc = -EINVAL;
pr_err("%s(): Unsupported format %u\n", __func__, format);
goto do_rotate_exit;
}
if (rc != 0) {
msm_rotator_dev->last_session_idx = INVALID_SESSION;
pr_err("%s(): Invalid session error\n", __func__);
goto do_rotate_exit;
}
iowrite32(3, <API key>);
msm_rotator_dev->processing = 1;
iowrite32(0x1, MSM_ROTATOR_START);
wait_event(msm_rotator_dev->wq,
(msm_rotator_dev->processing == 0));
status = (unsigned char)ioread32(<API key>);
if ((status & 0x03) != 0x01) {
pr_err("%s(): AXI Bus Error, issuing SW_RESET\n", __func__);
iowrite32(0x1, <API key>);
rc = -EFAULT;
}
iowrite32(0, <API key>);
iowrite32(3, <API key>);
do_rotate_exit:
disable_irq(msm_rotator_dev->irq);
#ifdef <API key>
<API key>(ROTATOR_REQUEST);
#endif
<API key>(&msm_rotator_dev->rot_clk_work, HZ);
put_img(dstp1_file, dstp1_ihdl, ROTATOR_DST_DOMAIN,
img_info->secure);
put_img(srcp1_file, srcp1_ihdl, ROTATOR_SRC_DOMAIN, 0);
put_img(dstp0_file, dstp0_ihdl, ROTATOR_DST_DOMAIN,
img_info->secure);
/* only source may use frame buffer */
if (info.src.flags & <API key>)
fput_light(srcp0_file, ps0_need);
else
put_img(srcp0_file, srcp0_ihdl, ROTATOR_SRC_DOMAIN, 0);
<API key>(s);
mutex_unlock(&msm_rotator_dev->rotator_lock);
dev_dbg(msm_rotator_dev->device, "%s() returning rc = %d\n",
__func__, rc);
return rc;
}
static void <API key>(u32 is_all)
{
int ret = 0;
u32 loop_cnt = 0;
while (1) {
mutex_lock(&mrd->commit_mutex);
if (is_all && (atomic_read(&mrd->commit_q_cnt) == 0))
break;
if ((!is_all) &&
(atomic_read(&mrd->commit_q_cnt) < MAX_COMMIT_QUEUE))
break;
INIT_COMPLETION(mrd->commit_comp);
mutex_unlock(&mrd->commit_mutex);
ret = <API key>(
&mrd->commit_comp,
msecs_to_jiffies(WAIT_ROT_TIMEOUT));
if ((ret <= 0) ||
(atomic_read(&mrd->commit_q_cnt) >= MAX_COMMIT_QUEUE) ||
(loop_cnt > MAX_COMMIT_QUEUE)) {
pr_err("%s wait for commit queue failed ret=%d pointers:%d %d",
__func__, ret, atomic_read(&mrd->commit_q_r),
atomic_read(&mrd->commit_q_w));
mutex_lock(&mrd->commit_mutex);
ret = -ETIME;
break;
} else {
ret = 0;
}
loop_cnt++;
};
if (is_all || ret) {
atomic_set(&mrd->commit_q_r, 0);
atomic_set(&mrd->commit_q_cnt, 0);
atomic_set(&mrd->commit_q_w, 0);
}
mutex_unlock(&mrd->commit_mutex);
}
static int <API key>(unsigned long arg)
{
struct <API key> info;
struct rot_sync_info *sync_info;
int session_index, ret;
int commit_q_w;
if (copy_from_user(&info, (void __user *)arg, sizeof(info)))
return -EFAULT;
<API key>(false);
mutex_lock(&mrd->commit_mutex);
commit_q_w = atomic_read(&mrd->commit_q_w);
ret = <API key>(&info,
&mrd->commit_info[commit_q_w]);
if (ret) {
mutex_unlock(&mrd->commit_mutex);
return ret;
}
session_index = mrd->commit_info[commit_q_w].session_index;
sync_info = &msm_rotator_dev->sync_info[session_index];
mutex_lock(&sync_info->sync_mutex);
atomic_inc(&sync_info->queue_buf_cnt);
sync_info->acq_fen = NULL;
mutex_unlock(&sync_info->sync_mutex);
if (atomic_inc_return(&mrd->commit_q_w) >= MAX_COMMIT_QUEUE)
atomic_set(&mrd->commit_q_w, 0);
atomic_inc(&mrd->commit_q_cnt);
schedule_work(&mrd->commit_work);
mutex_unlock(&mrd->commit_mutex);
if (info.wait_for_finish)
<API key>(true);
return 0;
}
static void <API key>(struct work_struct *work)
{
mutex_lock(&mrd->commit_wq_mutex);
mutex_lock(&mrd->commit_mutex);
while (atomic_read(&mrd->commit_q_cnt) > 0) {
mrd->commit_running = true;
mutex_unlock(&mrd->commit_mutex);
<API key>(
&mrd->commit_info[atomic_read(&mrd->commit_q_r)]);
mutex_lock(&mrd->commit_mutex);
if (atomic_read(&mrd->commit_q_cnt) > 0) {
atomic_dec(&mrd->commit_q_cnt);
if (atomic_inc_return(&mrd->commit_q_r) >=
MAX_COMMIT_QUEUE)
atomic_set(&mrd->commit_q_r, 0);
}
complete_all(&mrd->commit_comp);
}
mrd->commit_running = false;
if (atomic_read(&mrd->commit_q_r) != atomic_read(&mrd->commit_q_w))
pr_err("%s invalid state: r=%d w=%d cnt=%d", __func__,
atomic_read(&mrd->commit_q_r),
atomic_read(&mrd->commit_q_w),
atomic_read(&mrd->commit_q_cnt));
mutex_unlock(&mrd->commit_mutex);
mutex_unlock(&mrd->commit_wq_mutex);
}
static void <API key>(u32 wh, u32 is_rgb)
{
u32 perf_level;
if (is_rgb)
perf_level = 1;
else if (wh <= (640 * 480))
perf_level = 2;
else if (wh <= (736 * 1280))
perf_level = 3;
else
perf_level = 4;
#ifdef <API key>
<API key>(msm_rotator_dev->bus_client_handle,
perf_level);
#endif
}
static int <API key>(struct msm_rotator_dev *rot_dev)
{
int ret = 0, i;
if (rot_dev->mmu_clk_on)
return 0;
for (i = 0; i < ARRAY_SIZE(rot_mmu_clks); i++) {
rot_mmu_clks[i].mmu_clk = clk_get(&msm_rotator_dev->pdev->dev,
rot_mmu_clks[i].mmu_clk_name);
if (IS_ERR(rot_mmu_clks[i].mmu_clk)) {
pr_err(" %s: Get failed for clk %s", __func__,
rot_mmu_clks[i].mmu_clk_name);
ret = PTR_ERR(rot_mmu_clks[i].mmu_clk);
break;
}
ret = clk_prepare_enable(rot_mmu_clks[i].mmu_clk);
if (ret) {
clk_put(rot_mmu_clks[i].mmu_clk);
rot_mmu_clks[i].mmu_clk = NULL;
}
}
if (ret) {
for (i--; i >= 0; i--) {
<API key>(rot_mmu_clks[i].mmu_clk);
clk_put(rot_mmu_clks[i].mmu_clk);
rot_mmu_clks[i].mmu_clk = NULL;
}
} else {
rot_dev->mmu_clk_on = 1;
}
return ret;
}
static int <API key>(struct msm_rotator_dev *rot_dev)
{
int i;
if (!rot_dev->mmu_clk_on)
return 0;
for (i = 0; i < ARRAY_SIZE(rot_mmu_clks); i++) {
<API key>(rot_mmu_clks[i].mmu_clk);
clk_put(rot_mmu_clks[i].mmu_clk);
rot_mmu_clks[i].mmu_clk = NULL;
}
rot_dev->mmu_clk_on = 0;
return 0;
}
static int map_sec_resource(struct msm_rotator_dev *rot_dev)
{
int ret = 0;
if (rot_dev->sec_mapped)
return 0;
ret = <API key>(rot_dev);
if (ret) {
pr_err("IOMMU clock enabled failed while open");
return ret;
}
ret = msm_ion_secure_heap(ION_HEAP(ION_CP_MM_HEAP_ID));
if (ret)
pr_err("ION heap secure failed heap id %d ret %d\n",
ION_CP_MM_HEAP_ID, ret);
else
rot_dev->sec_mapped = 1;
<API key>(rot_dev);
return ret;
}
static int unmap_sec_resource(struct msm_rotator_dev *rot_dev)
{
int ret = 0;
ret = <API key>(rot_dev);
if (ret) {
pr_err("IOMMU clock enabled failed while close\n");
return ret;
}
<API key>(ION_HEAP(ION_CP_MM_HEAP_ID));
rot_dev->sec_mapped = 0;
<API key>(rot_dev);
return ret;
}
static int msm_rotator_start(unsigned long arg,
struct msm_rotator_fd_info *fd_info)
{
struct <API key> info;
struct msm_rotator_session *rot_session = NULL;
int rc = 0;
int s, is_rgb = 0;
int first_free_idx = INVALID_SESSION;
unsigned int dst_w, dst_h;
unsigned int is_planar420 = 0;
int fast_yuv_en = 0, enable_2pass = 0;
struct rot_sync_info *sync_info;
if (copy_from_user(&info, (void __user *)arg, sizeof(info)))
return -EFAULT;
if ((info.rotations > MSM_ROTATOR_MAX_ROT) ||
(info.src.height > MSM_ROTATOR_MAX_H) ||
(info.src.width > MSM_ROTATOR_MAX_W) ||
(info.dst.height > MSM_ROTATOR_MAX_H) ||
(info.dst.width > MSM_ROTATOR_MAX_W) ||
(info.downscale_ratio > MAX_DOWNSCALE_RATIO)) {
pr_err("%s: Invalid parameters\n", __func__);
return -EINVAL;
}
if (info.rotations & MDP_ROT_90) {
dst_w = info.src_rect.h >> info.downscale_ratio;
dst_h = info.src_rect.w >> info.downscale_ratio;
} else {
dst_w = info.src_rect.w >> info.downscale_ratio;
dst_h = info.src_rect.h >> info.downscale_ratio;
}
if (checkoffset(info.src_rect.x, info.src_rect.w, info.src.width) ||
checkoffset(info.src_rect.y, info.src_rect.h, info.src.height) ||
checkoffset(info.dst_x, dst_w, info.dst.width) ||
checkoffset(info.dst_y, dst_h, info.dst.height)) {
pr_err("%s: Invalid src or dst rect\n", __func__);
return -ERANGE;
}
switch (info.src.format) {
case MDP_Y_CB_CR_H2V2:
case MDP_Y_CR_CB_H2V2:
case MDP_Y_CR_CB_GH2V2:
is_planar420 = 1;
case MDP_Y_CBCR_H2V2:
case MDP_Y_CRCB_H2V2:
case <API key>:
case <API key>:
if (rotator_hw_revision >= ROTATOR_REVISION_V2) {
if (info.downscale_ratio &&
(info.rotations & MDP_ROT_90)) {
fast_yuv_en = !<API key>(
0,
info.src.width,
info.src_rect.w >>
info.downscale_ratio,
info.src.height,
info.src_rect.h >>
info.downscale_ratio,
info.src_rect.w >>
info.downscale_ratio,
is_planar420);
fast_yuv_en = fast_yuv_en &&
!<API key>(
info.rotations,
info.src_rect.w >>
info.downscale_ratio,
dst_w,
info.src_rect.h >>
info.downscale_ratio,
dst_h,
dst_w,
is_planar420);
} else {
fast_yuv_en = !<API key>(
info.rotations,
info.src.width,
dst_w,
info.src.height,
dst_h,
dst_w,
is_planar420);
}
if (fast_yuv_en && info.downscale_ratio &&
(info.rotations & MDP_ROT_90))
enable_2pass = 1;
}
break;
default:
fast_yuv_en = 0;
}
switch (info.src.format) {
case MDP_RGB_565:
case MDP_BGR_565:
case MDP_RGB_888:
case MDP_ARGB_8888:
case MDP_RGBA_8888:
case MDP_XRGB_8888:
case MDP_RGBX_8888:
case MDP_BGRA_8888:
is_rgb = 1;
info.dst.format = info.src.format;
break;
case MDP_Y_CBCR_H2V1:
if (info.rotations & MDP_ROT_90) {
info.dst.format = MDP_Y_CBCR_H1V2;
break;
}
case MDP_Y_CRCB_H2V1:
if (info.rotations & MDP_ROT_90) {
info.dst.format = MDP_Y_CRCB_H1V2;
break;
}
case MDP_Y_CBCR_H2V2:
case MDP_Y_CRCB_H2V2:
case MDP_YCBCR_H1V1:
case MDP_YCRCB_H1V1:
info.dst.format = info.src.format;
break;
case MDP_YCRYCB_H2V1:
if (info.rotations & MDP_ROT_90)
info.dst.format = MDP_Y_CRCB_H1V2;
else
info.dst.format = MDP_Y_CRCB_H2V1;
break;
case MDP_Y_CB_CR_H2V2:
if (fast_yuv_en) {
info.dst.format = info.src.format;
break;
}
case <API key>:
info.dst.format = MDP_Y_CBCR_H2V2;
break;
case MDP_Y_CR_CB_H2V2:
case MDP_Y_CR_CB_GH2V2:
if (fast_yuv_en) {
info.dst.format = info.src.format;
break;
}
case <API key>:
info.dst.format = MDP_Y_CRCB_H2V2;
break;
default:
return -EINVAL;
}
mutex_lock(&msm_rotator_dev->rotator_lock);
<API key>((info.src.width*info.src.height), is_rgb);
for (s = 0; s < MAX_SESSIONS; s++) {
if ((msm_rotator_dev->rot_session[s] != NULL) &&
(info.session_id ==
(unsigned int)msm_rotator_dev->rot_session[s]
)) {
rot_session = msm_rotator_dev->rot_session[s];
rot_session->img_info = info;
rot_session->fd_info = *fd_info;
rot_session->fast_yuv_enable = fast_yuv_en;
rot_session->enable_2pass = enable_2pass;
if (msm_rotator_dev->last_session_idx == s)
msm_rotator_dev->last_session_idx =
INVALID_SESSION;
break;
}
if ((msm_rotator_dev->rot_session[s] == NULL) &&
(first_free_idx == INVALID_SESSION))
first_free_idx = s;
}
if ((s == MAX_SESSIONS) && (first_free_idx != INVALID_SESSION)) {
/* allocate a session id */
msm_rotator_dev->rot_session[first_free_idx] =
kzalloc(sizeof(struct msm_rotator_session),
GFP_KERNEL);
if (!msm_rotator_dev->rot_session[first_free_idx]) {
printk(KERN_ERR "%s : unable to alloc mem\n",
__func__);
rc = -ENOMEM;
goto rotator_start_exit;
}
info.session_id = (unsigned int)
msm_rotator_dev->rot_session[first_free_idx];
rot_session = msm_rotator_dev->rot_session[first_free_idx];
rot_session->img_info = info;
rot_session->fd_info = *fd_info;
rot_session->fast_yuv_enable = fast_yuv_en;
rot_session->enable_2pass = enable_2pass;
if (!IS_ERR_OR_NULL(mrd->client)) {
if (rot_session->img_info.secure) {
rot_session->mem_hid &= ~BIT(ION_IOMMU_HEAP_ID);
rot_session->mem_hid |= BIT(ION_CP_MM_HEAP_ID);
rot_session->mem_hid |= ION_SECURE;
} else {
rot_session->mem_hid &= ~BIT(ION_CP_MM_HEAP_ID);
rot_session->mem_hid &= ~ION_SECURE;
rot_session->mem_hid |= BIT(ION_IOMMU_HEAP_ID);
}
}
s = first_free_idx;
} else if (s == MAX_SESSIONS) {
dev_dbg(msm_rotator_dev->device, "%s: all sessions in use\n",
__func__);
rc = -EBUSY;
}
if (rc == 0 && copy_to_user((void __user *)arg, &info, sizeof(info)))
rc = -EFAULT;
if ((rc == 0) && (info.secure))
map_sec_resource(msm_rotator_dev);
sync_info = &msm_rotator_dev->sync_info[s];
if ((rc == 0) && (sync_info->initialized == false)) {
char timeline_name[<API key>];
if (sync_info->timeline == NULL) {
snprintf(timeline_name, sizeof(timeline_name),
"msm_rot_%d", first_free_idx);
sync_info->timeline =
<API key>(timeline_name);
if (sync_info->timeline == NULL)
pr_err("%s: cannot create %s time line",
__func__, timeline_name);
sync_info->timeline_value = 0;
}
mutex_init(&sync_info->sync_mutex);
sync_info->initialized = true;
}
sync_info->acq_fen = NULL;
atomic_set(&sync_info->queue_buf_cnt, 0);
rotator_start_exit:
mutex_unlock(&msm_rotator_dev->rotator_lock);
return rc;
}
static int msm_rotator_finish(unsigned long arg)
{
int rc = 0;
int s;
unsigned int session_id;
if (copy_from_user(&session_id, (void __user *)arg, sizeof(s)))
return -EFAULT;
<API key>(true);
mutex_lock(&msm_rotator_dev->rotator_lock);
for (s = 0; s < MAX_SESSIONS; s++) {
if ((msm_rotator_dev->rot_session[s] != NULL) &&
(session_id ==
(unsigned int)msm_rotator_dev->rot_session[s])) {
if (msm_rotator_dev->last_session_idx == s)
msm_rotator_dev->last_session_idx =
INVALID_SESSION;
<API key>(s);
<API key>(s);
if (msm_rotator_dev->rot_session[s]->enable_2pass) {
<API key>(mrd->y_rot_buf, s);
<API key>(mrd->chroma_rot_buf, s);
<API key>(mrd->chroma2_rot_buf, s);
}
kfree(msm_rotator_dev->rot_session[s]);
msm_rotator_dev->rot_session[s] = NULL;
break;
}
}
if (s == MAX_SESSIONS)
rc = -EINVAL;
#ifdef <API key>
<API key>(msm_rotator_dev->bus_client_handle,
0);
#endif
if (msm_rotator_dev->sec_mapped)
unmap_sec_resource(msm_rotator_dev);
mutex_unlock(&msm_rotator_dev->rotator_lock);
return rc;
}
static int
msm_rotator_open(struct inode *inode, struct file *filp)
{
struct msm_rotator_fd_info *tmp, *fd_info = NULL;
int i;
if (filp->private_data)
return -EBUSY;
mutex_lock(&msm_rotator_dev->rotator_lock);
for (i = 0; i < MAX_SESSIONS; i++) {
if (msm_rotator_dev->rot_session[i] == NULL)
break;
}
if (i == MAX_SESSIONS) {
mutex_unlock(&msm_rotator_dev->rotator_lock);
return -EBUSY;
}
list_for_each_entry(tmp, &msm_rotator_dev->fd_list, list) {
if (tmp->pid == current->pid) {
fd_info = tmp;
break;
}
}
if (!fd_info) {
fd_info = kzalloc(sizeof(*fd_info), GFP_KERNEL);
if (!fd_info) {
mutex_unlock(&msm_rotator_dev->rotator_lock);
pr_err("%s: insufficient memory to alloc resources\n",
__func__);
return -ENOMEM;
}
list_add(&fd_info->list, &msm_rotator_dev->fd_list);
fd_info->pid = current->pid;
}
fd_info->ref_cnt++;
mutex_unlock(&msm_rotator_dev->rotator_lock);
filp->private_data = fd_info;
return 0;
}
static int
msm_rotator_close(struct inode *inode, struct file *filp)
{
struct msm_rotator_fd_info *fd_info;
int s;
fd_info = (struct msm_rotator_fd_info *)filp->private_data;
mutex_lock(&msm_rotator_dev->rotator_lock);
if (--fd_info->ref_cnt > 0) {
mutex_unlock(&msm_rotator_dev->rotator_lock);
return 0;
}
for (s = 0; s < MAX_SESSIONS; s++) {
if (msm_rotator_dev->rot_session[s] != NULL &&
&(msm_rotator_dev->rot_session[s]->fd_info) == fd_info) {
pr_debug("%s: freeing rotator session %p (pid %d)\n",
__func__, msm_rotator_dev->rot_session[s],
fd_info->pid);
<API key>(true);
<API key>(s);
kfree(msm_rotator_dev->rot_session[s]);
msm_rotator_dev->rot_session[s] = NULL;
if (msm_rotator_dev->last_session_idx == s)
msm_rotator_dev->last_session_idx =
INVALID_SESSION;
}
}
list_del(&fd_info->list);
kfree(fd_info);
mutex_unlock(&msm_rotator_dev->rotator_lock);
return 0;
}
static long msm_rotator_ioctl(struct file *file, unsigned cmd,
unsigned long arg)
{
struct msm_rotator_fd_info *fd_info;
if (_IOC_TYPE(cmd) != <API key>)
return -ENOTTY;
fd_info = (struct msm_rotator_fd_info *)file->private_data;
switch (cmd) {
case <API key>:
return msm_rotator_start(arg, fd_info);
case <API key>:
return <API key>(arg);
case <API key>:
return msm_rotator_finish(arg);
case <API key>:
return <API key>(arg);
default:
dev_dbg(msm_rotator_dev->device,
"unexpected IOCTL %d\n", cmd);
return -ENOTTY;
}
}
static const struct file_operations msm_rotator_fops = {
.owner = THIS_MODULE,
.open = msm_rotator_open,
.release = msm_rotator_close,
.unlocked_ioctl = msm_rotator_ioctl,
};
static int __devinit msm_rotator_probe(struct platform_device *pdev)
{
int rc = 0;
struct resource *res;
struct <API key> *pdata = NULL;
int i, number_of_clks;
uint32_t ver;
msm_rotator_dev = kzalloc(sizeof(struct msm_rotator_dev), GFP_KERNEL);
if (!msm_rotator_dev) {
printk(KERN_ERR "%s Unable to allocate memory for struct\n",
__func__);
return -ENOMEM;
}
for (i = 0; i < MAX_SESSIONS; i++)
msm_rotator_dev->rot_session[i] = NULL;
msm_rotator_dev->last_session_idx = INVALID_SESSION;
pdata = pdev->dev.platform_data;
number_of_clks = pdata->number_of_clocks;
<API key> = pdata-><API key>;
msm_rotator_dev->imem_owner = IMEM_NO_OWNER;
mutex_init(&msm_rotator_dev->imem_lock);
INIT_LIST_HEAD(&msm_rotator_dev->fd_list);
msm_rotator_dev->imem_clk_state = CLK_DIS;
INIT_DELAYED_WORK(&msm_rotator_dev->imem_clk_work,
<API key>);
msm_rotator_dev->imem_clk = NULL;
msm_rotator_dev->pdev = pdev;
msm_rotator_dev->core_clk = NULL;
msm_rotator_dev->pclk = NULL;
mrd->y_rot_buf = kmalloc(sizeof(struct rot_buf_type), GFP_KERNEL);
mrd->chroma_rot_buf = kmalloc(sizeof(struct rot_buf_type), GFP_KERNEL);
mrd->chroma2_rot_buf = kmalloc(sizeof(struct rot_buf_type), GFP_KERNEL);
memset((void *)mrd->y_rot_buf, 0, sizeof(struct rot_buf_type));
memset((void *)mrd->chroma_rot_buf, 0, sizeof(struct rot_buf_type));
memset((void *)mrd->chroma2_rot_buf, 0, sizeof(struct rot_buf_type));
#ifdef <API key>
if (!msm_rotator_dev->bus_client_handle && pdata &&
pdata->bus_scale_table) {
msm_rotator_dev->bus_client_handle =
<API key>(
pdata->bus_scale_table);
if (!msm_rotator_dev->bus_client_handle) {
pr_err("%s not able to get bus scale handle\n",
__func__);
}
}
#endif
for (i = 0; i < number_of_clks; i++) {
if (pdata->rotator_clks[i].clk_type == ROTATOR_IMEM_CLK) {
msm_rotator_dev->imem_clk =
clk_get(&msm_rotator_dev->pdev->dev,
pdata->rotator_clks[i].clk_name);
if (IS_ERR(msm_rotator_dev->imem_clk)) {
rc = PTR_ERR(msm_rotator_dev->imem_clk);
msm_rotator_dev->imem_clk = NULL;
printk(KERN_ERR "%s: cannot get imem_clk "
"rc=%d\n", DRIVER_NAME, rc);
goto error_imem_clk;
}
if (pdata->rotator_clks[i].clk_rate)
clk_set_rate(msm_rotator_dev->imem_clk,
pdata->rotator_clks[i].clk_rate);
}
if (pdata->rotator_clks[i].clk_type == ROTATOR_PCLK) {
msm_rotator_dev->pclk =
clk_get(&msm_rotator_dev->pdev->dev,
pdata->rotator_clks[i].clk_name);
if (IS_ERR(msm_rotator_dev->pclk)) {
rc = PTR_ERR(msm_rotator_dev->pclk);
msm_rotator_dev->pclk = NULL;
printk(KERN_ERR "%s: cannot get pclk rc=%d\n",
DRIVER_NAME, rc);
goto error_pclk;
}
if (pdata->rotator_clks[i].clk_rate)
clk_set_rate(msm_rotator_dev->pclk,
pdata->rotator_clks[i].clk_rate);
}
if (pdata->rotator_clks[i].clk_type == ROTATOR_CORE_CLK) {
msm_rotator_dev->core_clk =
clk_get(&msm_rotator_dev->pdev->dev,
pdata->rotator_clks[i].clk_name);
if (IS_ERR(msm_rotator_dev->core_clk)) {
rc = PTR_ERR(msm_rotator_dev->core_clk);
msm_rotator_dev->core_clk = NULL;
printk(KERN_ERR "%s: cannot get core clk "
"rc=%d\n", DRIVER_NAME, rc);
goto error_core_clk;
}
if (pdata->rotator_clks[i].clk_rate)
clk_set_rate(msm_rotator_dev->core_clk,
pdata->rotator_clks[i].clk_rate);
}
}
msm_rotator_dev->regulator = regulator_get(&msm_rotator_dev->pdev->dev,
"vdd");
if (IS_ERR(msm_rotator_dev->regulator))
msm_rotator_dev->regulator = NULL;
msm_rotator_dev->rot_clk_state = CLK_DIS;
INIT_DELAYED_WORK(&msm_rotator_dev->rot_clk_work,
<API key>);
mutex_init(&msm_rotator_dev->rotator_lock);
#ifdef <API key>
msm_rotator_dev->client = <API key>(-1, pdev->name);
#endif
<API key>(pdev, msm_rotator_dev);
res = <API key>(pdev, IORESOURCE_MEM, 0);
if (!res) {
printk(KERN_ALERT
"%s: could not get IORESOURCE_MEM\n", DRIVER_NAME);
rc = -ENODEV;
goto error_get_resource;
}
msm_rotator_dev->io_base = ioremap(res->start,
resource_size(res));
#ifdef <API key>
if (msm_rotator_dev->imem_clk)
clk_prepare_enable(msm_rotator_dev->imem_clk);
#endif
enable_rot_clks();
ver = ioread32(<API key>);
disable_rot_clks();
#ifdef <API key>
if (msm_rotator_dev->imem_clk)
<API key>(msm_rotator_dev->imem_clk);
#endif
if (ver != pdata-><API key>)
pr_debug("%s: invalid HW version ver 0x%x\n",
DRIVER_NAME, ver);
rotator_hw_revision = ver;
rotator_hw_revision >>= 16; /* bit 31:16 */
rotator_hw_revision &= 0xff;
pr_info("%s: rotator_hw_revision=%x\n",
__func__, rotator_hw_revision);
msm_rotator_dev->irq = platform_get_irq(pdev, 0);
if (msm_rotator_dev->irq < 0) {
printk(KERN_ALERT "%s: could not get IORESOURCE_IRQ\n",
DRIVER_NAME);
rc = -ENODEV;
goto error_get_irq;
}
rc = request_irq(msm_rotator_dev->irq, msm_rotator_isr,
IRQF_TRIGGER_RISING, DRIVER_NAME, NULL);
if (rc) {
printk(KERN_ERR "%s: request_irq() failed\n", DRIVER_NAME);
goto error_get_irq;
}
/* we enable the IRQ when we need it in the ioctl */
disable_irq(msm_rotator_dev->irq);
rc = alloc_chrdev_region(&msm_rotator_dev->dev_num, 0, 1, DRIVER_NAME);
if (rc < 0) {
printk(KERN_ERR "%s: alloc_chrdev_region Failed rc = %d\n",
__func__, rc);
goto error_get_irq;
}
msm_rotator_dev->class = class_create(THIS_MODULE, DRIVER_NAME);
if (IS_ERR(msm_rotator_dev->class)) {
rc = PTR_ERR(msm_rotator_dev->class);
printk(KERN_ERR "%s: couldn't create class rc = %d\n",
DRIVER_NAME, rc);
goto error_class_create;
}
msm_rotator_dev->device = device_create(msm_rotator_dev->class, NULL,
msm_rotator_dev->dev_num, NULL,
DRIVER_NAME);
if (IS_ERR(msm_rotator_dev->device)) {
rc = PTR_ERR(msm_rotator_dev->device);
printk(KERN_ERR "%s: device_create failed %d\n",
DRIVER_NAME, rc);
goto <API key>;
}
cdev_init(&msm_rotator_dev->cdev, &msm_rotator_fops);
rc = cdev_add(&msm_rotator_dev->cdev,
MKDEV(MAJOR(msm_rotator_dev->dev_num), 0),
1);
if (rc < 0) {
printk(KERN_ERR "%s: cdev_add failed %d\n", __func__, rc);
goto error_cdev_add;
}
init_waitqueue_head(&msm_rotator_dev->wq);
INIT_WORK(&msm_rotator_dev->commit_work, <API key>);
init_completion(&msm_rotator_dev->commit_comp);
mutex_init(&msm_rotator_dev->commit_mutex);
mutex_init(&msm_rotator_dev->commit_wq_mutex);
atomic_set(&msm_rotator_dev->commit_q_w, 0);
atomic_set(&msm_rotator_dev->commit_q_r, 0);
atomic_set(&msm_rotator_dev->commit_q_cnt, 0);
dev_dbg(msm_rotator_dev->device, "probe successful\n");
return rc;
error_cdev_add:
device_destroy(msm_rotator_dev->class, msm_rotator_dev->dev_num);
<API key>:
class_destroy(msm_rotator_dev->class);
error_class_create:
<API key>(msm_rotator_dev->dev_num, 1);
error_get_irq:
iounmap(msm_rotator_dev->io_base);
error_get_resource:
mutex_destroy(&msm_rotator_dev->rotator_lock);
if (msm_rotator_dev->regulator)
regulator_put(msm_rotator_dev->regulator);
clk_put(msm_rotator_dev->core_clk);
error_core_clk:
clk_put(msm_rotator_dev->pclk);
error_pclk:
if (msm_rotator_dev->imem_clk)
clk_put(msm_rotator_dev->imem_clk);
error_imem_clk:
mutex_destroy(&msm_rotator_dev->imem_lock);
kfree(msm_rotator_dev);
return rc;
}
static int __devexit msm_rotator_remove(struct platform_device *plat_dev)
{
int i;
<API key>(true);
#ifdef <API key>
if (msm_rotator_dev->bus_client_handle) {
<API key>
(msm_rotator_dev->bus_client_handle);
msm_rotator_dev->bus_client_handle = 0;
}
#endif
free_irq(msm_rotator_dev->irq, NULL);
mutex_destroy(&msm_rotator_dev->rotator_lock);
cdev_del(&msm_rotator_dev->cdev);
device_destroy(msm_rotator_dev->class, msm_rotator_dev->dev_num);
class_destroy(msm_rotator_dev->class);
<API key>(msm_rotator_dev->dev_num, 1);
iounmap(msm_rotator_dev->io_base);
if (msm_rotator_dev->imem_clk) {
if (msm_rotator_dev->imem_clk_state == CLK_EN)
<API key>(msm_rotator_dev->imem_clk);
clk_put(msm_rotator_dev->imem_clk);
msm_rotator_dev->imem_clk = NULL;
}
if (msm_rotator_dev->rot_clk_state == CLK_EN)
disable_rot_clks();
clk_put(msm_rotator_dev->core_clk);
clk_put(msm_rotator_dev->pclk);
if (msm_rotator_dev->regulator)
regulator_put(msm_rotator_dev->regulator);
msm_rotator_dev->core_clk = NULL;
msm_rotator_dev->pclk = NULL;
mutex_destroy(&msm_rotator_dev->imem_lock);
for (i = 0; i < MAX_SESSIONS; i++)
if (msm_rotator_dev->rot_session[i] != NULL)
kfree(msm_rotator_dev->rot_session[i]);
kfree(msm_rotator_dev);
return 0;
}
#ifdef CONFIG_PM
static int msm_rotator_suspend(struct platform_device *dev, pm_message_t state)
{
<API key>(true);
mutex_lock(&msm_rotator_dev->imem_lock);
if (msm_rotator_dev->imem_clk_state == CLK_EN
&& msm_rotator_dev->imem_clk) {
<API key>(msm_rotator_dev->imem_clk);
msm_rotator_dev->imem_clk_state = CLK_SUSPEND;
}
mutex_unlock(&msm_rotator_dev->imem_lock);
mutex_lock(&msm_rotator_dev->rotator_lock);
if (msm_rotator_dev->rot_clk_state == CLK_EN) {
disable_rot_clks();
msm_rotator_dev->rot_clk_state = CLK_SUSPEND;
}
<API key>();
mutex_unlock(&msm_rotator_dev->rotator_lock);
return 0;
}
static int msm_rotator_resume(struct platform_device *dev)
{
mutex_lock(&msm_rotator_dev->imem_lock);
if (msm_rotator_dev->imem_clk_state == CLK_SUSPEND
&& msm_rotator_dev->imem_clk) {
clk_prepare_enable(msm_rotator_dev->imem_clk);
msm_rotator_dev->imem_clk_state = CLK_EN;
}
mutex_unlock(&msm_rotator_dev->imem_lock);
mutex_lock(&msm_rotator_dev->rotator_lock);
if (msm_rotator_dev->rot_clk_state == CLK_SUSPEND) {
enable_rot_clks();
msm_rotator_dev->rot_clk_state = CLK_EN;
}
mutex_unlock(&msm_rotator_dev->rotator_lock);
return 0;
}
#endif
static struct platform_driver <API key> = {
.probe = msm_rotator_probe,
.remove = __devexit_p(msm_rotator_remove),
#ifdef CONFIG_PM
.suspend = msm_rotator_suspend,
.resume = msm_rotator_resume,
#endif
.driver = {
.owner = THIS_MODULE,
.name = DRIVER_NAME
}
};
static int __init msm_rotator_init(void)
{
return <API key>(&<API key>);
}
static void __exit msm_rotator_exit(void)
{
return <API key>(&<API key>);
}
module_init(msm_rotator_init);
module_exit(msm_rotator_exit);
MODULE_DESCRIPTION("MSM Offline Image Rotator driver");
MODULE_VERSION("1.0");
MODULE_LICENSE("GPL v2");
|
using System;
using Server;
using Server.Gumps;
using Server.Network;
namespace Server.Items
{
public class PowerScroll : Item
{
private SkillName m_Skill;
private double m_Value;
private static SkillName[] m_Skills = new SkillName[]
{
SkillName.Blacksmith,
SkillName.Tailoring,
SkillName.Swords,
SkillName.Fencing,
SkillName.Macing,
SkillName.Archery,
SkillName.Wrestling,
SkillName.Parry,
SkillName.Tactics,
SkillName.Anatomy,
SkillName.Healing,
SkillName.Magery,
SkillName.Meditation,
SkillName.EvalInt,
SkillName.MagicResist,
SkillName.AnimalTaming,
SkillName.AnimalLore,
SkillName.Veterinary,
SkillName.Musicianship,
SkillName.Provocation,
SkillName.Discordance,
SkillName.Peacemaking
};
private static SkillName[] m_AOSSkills = new SkillName[]
{
SkillName.Blacksmith,
SkillName.Tailoring,
SkillName.Swords,
SkillName.Fencing,
SkillName.Macing,
SkillName.Archery,
SkillName.Wrestling,
SkillName.Parry,
SkillName.Tactics,
SkillName.Anatomy,
SkillName.Healing,
SkillName.Magery,
SkillName.Meditation,
SkillName.EvalInt,
SkillName.MagicResist,
SkillName.AnimalTaming,
SkillName.AnimalLore,
SkillName.Veterinary,
SkillName.Musicianship,
SkillName.Provocation,
SkillName.Discordance,
SkillName.Peacemaking,
SkillName.Chivalry,
SkillName.Focus,
SkillName.Necromancy,
SkillName.Stealing,
SkillName.Stealth,
SkillName.SpiritSpeak
};
private static SkillName[] m_SESkills = new SkillName[]
{
SkillName.Blacksmith,
SkillName.Tailoring,
SkillName.Swords,
SkillName.Fencing,
SkillName.Macing,
SkillName.Archery,
SkillName.Wrestling,
SkillName.Parry,
SkillName.Tactics,
SkillName.Anatomy,
SkillName.Healing,
SkillName.Magery,
SkillName.Meditation,
SkillName.EvalInt,
SkillName.MagicResist,
SkillName.AnimalTaming,
SkillName.AnimalLore,
SkillName.Veterinary,
SkillName.Musicianship,
SkillName.Provocation,
SkillName.Discordance,
SkillName.Peacemaking,
SkillName.Chivalry,
SkillName.Focus,
SkillName.Necromancy,
SkillName.Stealing,
SkillName.Stealth,
SkillName.SpiritSpeak,
SkillName.Ninjitsu,
SkillName.Bushido
};
private static SkillName[] m_MLSkills = new SkillName[]
{
SkillName.Blacksmith,
SkillName.Tailoring,
SkillName.Swords,
SkillName.Fencing,
SkillName.Macing,
SkillName.Archery,
SkillName.Wrestling,
SkillName.Parry,
SkillName.Tactics,
SkillName.Anatomy,
SkillName.Healing,
SkillName.Magery,
SkillName.Meditation,
SkillName.EvalInt,
SkillName.MagicResist,
SkillName.AnimalTaming,
SkillName.AnimalLore,
SkillName.Veterinary,
SkillName.Musicianship,
SkillName.Provocation,
SkillName.Discordance,
SkillName.Peacemaking,
SkillName.Chivalry,
SkillName.Focus,
SkillName.Necromancy,
SkillName.Stealing,
SkillName.Stealth,
SkillName.SpiritSpeak,
SkillName.Ninjitsu,
SkillName.Bushido,
SkillName.Spellweaving
};
public static SkillName[] Skills{ get{ return ( Core.ML ? m_MLSkills : Core.SE ? m_SESkills : Core.AOS ? m_AOSSkills : m_Skills ); } }
public static PowerScroll CreateRandom( int min, int max )
{
min /= 5;
max /= 5;
SkillName[] skills = PowerScroll.Skills;
return new PowerScroll( skills[Utility.Random( skills.Length )], 100 + (Utility.RandomMinMax( min, max ) * 5));
}
public static PowerScroll CreateRandomNoCraft( int min, int max )
{
min /= 5;
max /= 5;
SkillName[] skills = PowerScroll.Skills;
SkillName skillName;
do
{
skillName = skills[Utility.Random( skills.Length )];
} while ( skillName == SkillName.Blacksmith || skillName == SkillName.Tailoring );
return new PowerScroll( skillName, 100 + (Utility.RandomMinMax( min, max ) * 5));
}
[Constructable]
public PowerScroll( SkillName skill, double value ) : base( 0x14F0 )
{
base.Hue = 0x481;
base.Weight = 1.0;
m_Skill = skill;
m_Value = value;
if ( m_Value > 105.0 )
LootType = LootType.Cursed;
}
public PowerScroll( Serial serial ) : base( serial )
{
}
[CommandProperty( AccessLevel.GameMaster )]
public SkillName Skill
{
get
{
return m_Skill;
}
set
{
m_Skill = value;
}
}
[CommandProperty( AccessLevel.GameMaster )]
public double Value
{
get
{
return m_Value;
}
set
{
m_Value = value;
}
}
private string GetNameLocalized()
{
return String.Concat( "#", (1044060 + (int)m_Skill).ToString() );
}
private string GetName()
{
int index = (int)m_Skill;
SkillInfo[] table = SkillInfo.Table;
if ( index >= 0 && index < table.Length )
return table[index].Name.ToLower();
else
return "???";
}
public override void AddNameProperty(ObjectPropertyList list)
{
if ( m_Value == 105.0 )
list.Add( 1049639, GetNameLocalized() ); // a wonderous scroll of ~1_type~ (105 Skill)
else if ( m_Value == 110.0 )
list.Add( 1049640, GetNameLocalized() ); // an exalted scroll of ~1_type~ (110 Skill)
else if ( m_Value == 115.0 )
list.Add( 1049641, GetNameLocalized() ); // a mythical scroll of ~1_type~ (115 Skill)
else if ( m_Value == 120.0 )
list.Add( 1049642, GetNameLocalized() ); // a legendary scroll of ~1_type~ (120 Skill)
else
list.Add( "a power scroll of {0} ({1} Skill)", GetName(), m_Value );
}
public override void OnSingleClick( Mobile from )
{
if ( m_Value == 105.0 )
base.LabelTo( from, 1049639, GetNameLocalized() ); // a wonderous scroll of ~1_type~ (105 Skill)
else if ( m_Value == 110.0 )
base.LabelTo( from, 1049640, GetNameLocalized() ); // an exalted scroll of ~1_type~ (110 Skill)
else if ( m_Value == 115.0 )
base.LabelTo( from, 1049641, GetNameLocalized() ); // a mythical scroll of ~1_type~ (115 Skill)
else if ( m_Value == 120.0 )
base.LabelTo( from, 1049642, GetNameLocalized() ); // a legendary scroll of ~1_type~ (120 Skill)
else
base.LabelTo( from, "a power scroll of {0} ({1} Skill)", GetName(), m_Value );
}
public void Use( Mobile from, bool firstStage )
{
if ( Deleted )
return;
if ( IsChildOf( from.Backpack ) )
{
Skill skill = from.Skills[m_Skill];
if ( skill != null )
{
if ( skill.Cap >= m_Value )
{
from.<API key>( 1049511, GetNameLocalized() ); // Your ~1_type~ is too high for this power scroll.
}
else
{
if ( firstStage )
{
from.CloseGump( typeof( StatCapScroll.InternalGump ) );
from.CloseGump( typeof( PowerScroll.InternalGump ) );
from.SendGump( new InternalGump( from, this ) );
}
else
{
from.<API key>( 1049513, GetNameLocalized() ); // You feel a surge of magic as the scroll enhances your ~1_type~!
skill.Cap = m_Value;
Effects.<API key>( EffectItem.Create( from.Location, from.Map, EffectItem.DefaultDuration ), 0, 0, 0, 0, 0, 5060, 0 );
Effects.PlaySound( from.Location, from.Map, 0x243 );
Effects.SendMovingParticles( new Entity( Serial.Zero, new Point3D( from.X - 6, from.Y - 6, from.Z + 15 ), from.Map ), from, 0x36D4, 7, 0, false, true, 0x497, 0, 9502, 1, 0, (EffectLayer)255, 0x100 );
Effects.SendMovingParticles( new Entity( Serial.Zero, new Point3D( from.X - 4, from.Y - 6, from.Z + 15 ), from.Map ), from, 0x36D4, 7, 0, false, true, 0x497, 0, 9502, 1, 0, (EffectLayer)255, 0x100 );
Effects.SendMovingParticles( new Entity( Serial.Zero, new Point3D( from.X - 6, from.Y - 4, from.Z + 15 ), from.Map ), from, 0x36D4, 7, 0, false, true, 0x497, 0, 9502, 1, 0, (EffectLayer)255, 0x100 );
Effects.SendTargetParticles( from, 0x375A, 35, 90, 0x00, 0x00, 9502, (EffectLayer)255, 0x100 );
Delete();
}
}
}
}
else
{
from.<API key>( 1042001 ); // That must be in your pack for you to use it.
}
}
public override void OnDoubleClick( Mobile from )
{
Use( from, true );
}
public override void Serialize( GenericWriter writer )
{
base.Serialize( writer );
writer.Write( (int) 0 ); // version
writer.Write( (int) m_Skill );
writer.Write( (double) m_Value );
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt();
switch ( version )
{
case 0:
{
m_Skill = (SkillName)reader.ReadInt();
m_Value = reader.ReadDouble();
break;
}
}
if ( m_Value == 105.0 )
{
LootType = LootType.Regular;
}
else
{
LootType = LootType.Cursed;
if ( Insured )
Insured = false;
}
}
public class InternalGump : Gump
{
private Mobile m_Mobile;
private PowerScroll m_Scroll;
public InternalGump( Mobile mobile, PowerScroll scroll ) : base( 25, 50 )
{
m_Mobile = mobile;
m_Scroll = scroll;
AddPage( 0 );
AddBackground( 25, 10, 420, 200, 5054 );
AddImageTiled( 33, 20, 401, 181, 2624 );
AddAlphaRegion( 33, 20, 401, 181 );
AddHtmlLocalized( 40, 48, 387, 100, 1049469, true, true ); /* Using a scroll increases the maximum amount of a specific skill or your maximum statistics.
* When used, the effect is not immediately seen without a gain of points with that skill or statistics.
* You can view your maximum skill values in your skills window.
* You can view your maximum statistic value in your statistics window.
*/
AddHtmlLocalized( 125, 148, 200, 20, 1049478, 0xFFFFFF, false, false ); // Do you wish to use this scroll?
AddButton( 100, 172, 4005, 4007, 1, GumpButtonType.Reply, 0 );
AddHtmlLocalized( 135, 172, 120, 20, 1046362, 0xFFFFFF, false, false ); // Yes
AddButton( 275, 172, 4005, 4007, 0, GumpButtonType.Reply, 0 );
AddHtmlLocalized( 310, 172, 120, 20, 1046363, 0xFFFFFF, false, false );
double value = scroll.m_Value;
if ( value == 105.0 )
AddHtmlLocalized( 40, 20, 260, 20, 1049635, 0xFFFFFF, false, false ); // Wonderous Scroll (105 Skill):
else if ( value == 110.0 )
AddHtmlLocalized( 40, 20, 260, 20, 1049636, 0xFFFFFF, false, false ); // Exalted Scroll (110 Skill):
else if ( value == 115.0 )
AddHtmlLocalized( 40, 20, 260, 20, 1049637, 0xFFFFFF, false, false ); // Mythical Scroll (115 Skill):
else if ( value == 120.0 )
AddHtmlLocalized( 40, 20, 260, 20, 1049638, 0xFFFFFF, false, false ); // Legendary Scroll (120 Skill):
else
AddHtml( 40, 20, 260, 20, String.Format( "<basefont color=#FFFFFF>Power Scroll ({0} Skill):</basefont>", value ), false, false );
AddHtmlLocalized( 310, 20, 120, 20, 1044060 + (int)scroll.m_Skill, 0xFFFFFF, false, false );
}
public override void OnResponse( NetState state, RelayInfo info )
{
if ( info.ButtonID == 1 )
m_Scroll.Use( m_Mobile, false );
}
}
}
}
|
/*
[SENSOR]
Sensor Model:
Camera Module:
Lens Model:
Driver IC: = OV2655
PV Size = 640 x 480
Cap Size = 2048 x 1536
Output Format = YUYV
MCLK Speed = 24M
PV DVP_PCLK =
Cap DVP_PCLK =
PV Frame Rate = 30fps
Cap Frame Rate = 7.5fps
I2C Slave ID =
I2C Mode = 16Addr, 16Data
*/
#ifndef CAMSENSOR_OV2655
#define CAMSENSOR_OV2655
#define <API key>(pTbl) OV2655_WriteRegsTbl(pTbl,sizeof(pTbl)/sizeof(pTbl[0]))
enum ov2655_test_mode_t {
TEST_OFF,
TEST_1,
TEST_2,
TEST_3
};
enum ov2655_resolution_t {
QTR_SIZE,
FULL_SIZE,
HFR_60FPS,
HFR_90FPS,
HFR_120FPS,
INVALID_SIZE
};
typedef struct
{
unsigned int addr; /*Reg Addr :16Bit*/
unsigned int data; /*Reg Data :16Bit or 8Bit*/
unsigned int data_format; /*Reg Data Format:16Bit = 0,8Bit = 1*/
unsigned int delay_mask;
} OV2655_WREG, *POV2655_WREG;
OV2655_WREG ov2655_init_tbl[] =
{
{0x308c,0x80,1,0},
{0x308d,0x0e,1,0},
{0x360b,0x00,1,0},
{0x30b0,0xff,1,0},
{0x30b1,0xff,1,0},
{0x30b2,0x04,1,0},
{0x300e,0x34,1,0},
{0x300f,0xa6,1,0},
{0x3010,0x81,1,0},
{0x3082,0x01,1,0},
{0x30f4,0x01,1,0},
{0x3090,0x43,1,0},
{0x3091,0xc0,1,0},
{0x30ac,0x42,1,0},
{0x30d1,0x08,1,0},
{0x30a8,0x54,1,0},
{0x3015,0x02,1,0},
{0x3093,0x00,1,0},
{0x307e,0xe5,1,0},
{0x3079,0x00,1,0},
{0x30aa,0x52,1,0},
{0x3017,0x40,1,0},
{0x30f3,0x83,1,0},
{0x306a,0x0c,1,0},
{0x306d,0x00,1,0},
{0x336a,0x3c,1,0},
{0x3076,0x6a,1,0},
{0x30d9,0x95,1,0},
{0x3016,0x52,1,0},
{0x3601,0x30,1,0},
{0x304e,0x88,1,0},
{0x30f1,0x82,1,0},
{0x306f,0x14,1,0},
{0x302a,0x02,1,0},
{0x302b,0x84,1,0},
{0x3012,0x10,1,0},
{0x3011,0x01,1,0},//15fps
//;AEC/AGC
{0x3013,0xf7,1,0},
{0x301c,0x13,1,0},
{0x301d,0x17,1,0},
{0x3070,0x5c,1,0},
{0x3072,0x4d,1,0},
//;D5060
{0x30af,0x00,1,0},
{0x3048,0x1f,1,0},
{0x3049,0x4e,1,0},
{0x304a,0x20,1,0},
{0x304f,0x20,1,0},
{0x304b,0x02,1,0},
{0x304c,0x00,1,0},
{0x304d,0x02,1,0},
{0x304f,0x20,1,0},
{0x30a3,0x10,1,0},
{0x3013,0xf7,1,0},
{0x3014,0xa4,1,0},
{0x3071,0x00,1,0},
{0x3070,0xb9,1,0},
{0x3073,0x00,1,0},
{0x3072,0x4d,1,0},
{0x301c,0x03,1,0},
{0x301d,0x06,1,0},
{0x304d,0x42,1,0},
{0x304a,0x40,1,0},
{0x304f,0x40,1,0},
{0x3095,0x07,1,0},
{0x3096,0x16,1,0},
{0x3097,0x1d,1,0},
//;Window Setup
{0x3020,0x01,1,0},
{0x3021,0x18,1,0},
{0x3022,0x00,1,0},
{0x3023,0x06,1,0},
{0x3024,0x06,1,0},
{0x3025,0x58,1,0},
{0x3026,0x02,1,0},
{0x3027,0x61,1,0},
{0x3088,0x02,1,0},
{0x3089,0x80,1,0},
{0x308a,0x01,1,0},
{0x308b,0xe0,1,0},
{0x3316,0x64,1,0},
{0x3317,0x25,1,0},
{0x3318,0x80,1,0},
{0x3319,0x08,1,0},
{0x331a,0x28,1,0},
{0x331b,0x1e,1,0},
{0x331c,0x00,1,0},
{0x331d,0x38,1,0},
{0x3100,0x00,1,0},
//awb
{0x3320,0xfa,1,0},
{0x3321,0x11,1,0},
{0x3322,0x92,1,0},
{0x3323,0x01,1,0},
{0x3324,0x97,1,0},
{0x3325,0x02,1,0},
{0x3326,0xff,1,0},
{0x3327,0x10,1,0},
{0x3328,0x11,1,0},
{0x3329,0x0f,1,0},
{0x332a,0x58,1,0},
{0x332b,0x55,1,0},
{0x332c,0x90,1,0},
{0x332d,0xc0,1,0},
{0x332e,0x46,1,0},
{0x332f,0x2f,1,0},
{0x3330,0x2f,1,0},
{0x3331,0x44,1,0},
{0x3332,0xff,1,0},
{0x3333,0x00,1,0},
{0x3334,0xf0,1,0},
{0x3335,0xf0,1,0},
{0x3336,0xf0,1,0},
{0x3337,0x40,1,0},
{0x3338,0x40,1,0},
{0x3339,0x40,1,0},
{0x333a,0x00,1,0},
{0x333b,0x00,1,0},
//cmx
{0x3380,0x06,1,0},
{0x3381,0x90,1,0},
{0x3382,0x18,1,0},
{0x3383,0x31,1,0},
{0x3384,0x84,1,0},
{0x3385,0xb5,1,0},
{0x3386,0xba,1,0},
{0x3387,0xd2,1,0},
{0x3388,0x17,1,0},
{0x3389,0x9c,1,0},
{0x338a,0x00,1,0},
//gamma
{0x334f,0x20,1,0},
{0x3340,0x06,1,0},
{0x3341,0x14,1,0},
{0x3342,0x2b,1,0},
{0x3343,0x42,1,0},
{0x3344,0x55,1,0},
{0x3345,0x65,1,0},
{0x3346,0x70,1,0},
{0x3347,0x7c,1,0},
{0x3348,0x86,1,0},
{0x3349,0x96,1,0},
{0x334a,0xa3,1,0},
{0x334b,0xaf,1,0},
{0x334c,0xc4,1,0},
{0x334d,0xd7,1,0},
{0x334e,0xe8,1,0},
//;Lens correction
{0x3350,0x35,1,0},
{0x3351,0x29,1,0},
{0x3352,0x08,1,0},
{0x3353,0x24,1,0},
{0x3354,0x00,1,0},
{0x3355,0x85,1,0},
{0x3356,0x34,1,0},
{0x3357,0x29,1,0},
{0x3358,0x0f,1,0},
{0x3359,0x1d,1,0},
{0x335a,0x00,1,0},
{0x335b,0x85,1,0},
{0x335c,0x36,1,0},
{0x335d,0x2b,1,0},
{0x335e,0x08,1,0},
{0x335f,0x1b,1,0},
{0x3360,0x00,1,0},
{0x3361,0x85,1,0},
//lenc gain
{0x3363,0x03,1,0},
{0x3364,0x01,1,0},
{0x3365,0x02,1,0},
{0x3366,0x00,1,0},
{0x3362,0x90,1,0},//lenc for binning
//uv adjust
{0x338b,0x08,1,0},
{0x338c,0x10,1,0},
{0x338d,0x5f,1,0},
//Sharpness/De-noise
{0x3370,0xd0,1,0},
{0x3371,0x00,1,0},
{0x3372,0x00,1,0},
{0x3373,0x30,1,0},
{0x3374,0x10,1,0},
{0x3375,0x10,1,0},
{0x3376,0x08,1,0},
{0x3377,0x02,1,0},
{0x3378,0x04,1,0},
{0x3379,0x40,1,0},
//aec
{0x3018,0x70,1,0},
{0x3019,0x60,1,0},
{0x301a,0x85,1,0},
//;BLC
{0x3069,0x86,1,0},
{0x307c,0x13,1,0},
{0x3087,0x02,1,0},
//;blacksun
//;Avdd 2.55~3.0V
{0x3090,0x3b,1,0},
{0x30a8,0x54,1,0},
{0x30aa,0x82,1,0},
{0x30a3,0x91,1,0},
{0x30a1,0x41,1,0},
//;Other functions
{0x3300,0xfc,1,0},
{0x3302,0x11,1,0},
{0x3400,0x00,1,0},
{0x3606,0x20,1,0},
{0x3601,0x30,1,0},
{0x300e,0x34,1,0},
{0x30f3,0x83,1,0},
{0x304e,0x88,1,0},
};
OV2655_WREG <API key>[] =
{
//pclk=18M
//framerate:15fps
//YUVVGA(640x480)
{0x300e,0x3a,1,0},
{0x3010,0x81,1,0},
{0x3012,0x10,1,0},
{0x3014,0xac,1,0},
{0x3015,0x11,1,0},
{0x3016,0x82,1,0},
{0x3023,0x06,1,0},
{0x3026,0x02,1,0},
{0x3027,0x5e,1,0},
{0x302a,0x02,1,0},
{0x302b,0xe4,1,0},
{0x330c,0x00,1,0},
{0x3301,0xff,1,0},
{0x3069,0x80,1,0},
{0x306f,0x14,1,0},
{0x3088,0x03,1,0},
{0x3089,0x20,1,0},
{0x308a,0x02,1,0},
{0x308b,0x58,1,0},
{0x308e,0x00,1,0},
{0x30a1,0x41,1,0},
{0x30a3,0x80,1,0},
{0x30d9,0x95,1,0},
{0x3302,0x11,1,0},
{0x3317,0x25,1,0},
{0x3318,0x80,1,0},
{0x3319,0x08,1,0},
{0x331d,0x38,1,0},
{0x3373,0x40,1,0},
{0x3376,0x05,1,0},
{0x3362,0x90,1,0},
//svga->vga
{0x3302,0x11,1,0},
{0x3088,0x02,1,0},
{0x3089,0x80,1,0},
{0x308a,0x01,1,0},
{0x308b,0xe0,1,0},
{0x331a,0x28,1,0},
{0x331b,0x1e,1,0},
{0x331c,0x00,1,0},
{0x3302,0x11,1,0},
//mipi
{0x363b,0x01,1,0},
{0x309e,0x08,1,0},
{0x3606,0x00,1,0},
{0x3630,0x35,1,0},
{0x3086,0x0f,1,0},
{0x3086,0x00,1,0},
{0x304e,0x04,1,0},
{0x363b,0x01,1,0},
{0x309e,0x08,1,0},
{0x3606,0x00,1,0},
{0x3084,0x01,1,0},
{0x3010,0x81,1,0},
{0x3011,0x00,1,0},
{0x3634,0x26,1,0},
{0x3086,0x0f,1,0},
{0x3086,0x00,1,0},
//avoid black screen slash
{0x3000,0x15,1,0},
{0x3002,0x02,1,0},
{0x3003,0x6a,1,0},
};
OV2655_WREG <API key>[] =
{
};
OV2655_WREG <API key>[] =
{
};
OV2655_WREG ov2655_capture_tbl[]=
{
//pclk=24M
//framerate:7.5ps
{0x300e,0x34,1,0},
{0x3011,0x01,1,0},
{0x3010,0x81,1,0},
{0x3012,0x00,1,0},
{0x3015,0x02,1,0},
{0x3016,0xc2,1,0},
{0x3023,0x0c,1,0},
{0x3026,0x04,1,0},
{0x3027,0xbc,1,0},
{0x302a,0x04,1,0},
{0x302b,0xd4,1,0},
{0x3069,0x80,1,0},
{0x306f,0x54,1,0},
{0x3088,0x06,1,0},
{0x3089,0x40,1,0},
{0x308a,0x04,1,0},
{0x308b,0xb0,1,0},
{0x308e,0x64,1,0},
{0x30a1,0x41,1,0},
{0x30a3,0x80,1,0},
{0x30d9,0x95,1,0},
{0x3302,0x01,1,0},
{0x3317,0x4b,1,0},
{0x3318,0x00,1,0},
{0x3319,0x4c,1,0},
{0x331d,0x6c,1,0},
{0x3362,0x80,1,0},
{0x3373,0x40,1,0},
{0x3376,0x03,1,0},
};
OV2655_WREG <API key>[] =
{
//Contrast -4
{0x3391,0x04,1,0x04},
{0x3390,0x45,1,0x04},
{0x3398,0x14,1,0},
{0x3399,0x14,1,0},
};
OV2655_WREG <API key>[] =
{
//Contrast -3
{0x3391,0x04,1,0x04},
{0x3390,0x45,1,0x04},
{0x3398,0x14,1,0},
{0x3399,0x14,1,0},
};
OV2655_WREG <API key>[] =
{
//Contrast -2
{0x3391,0x04,1,0x04},
{0x3390,0x45,1,0x04},
{0x3398,0x18,1,0},
{0x3399,0x18,1,0},
};
OV2655_WREG <API key>[] =
{
//Contrast -1
{0x3391,0x04,1,0x04},
{0x3390,0x45,1,0x04},
{0x3398,0x1c,1,0},
{0x3399,0x1c,1,0},
};
OV2655_WREG <API key>[] =
{
//Contrast (Default)
{0x3391,0x04,1,0x04},
{0x3390,0x41,1,0x04},
{0x3398,0x20,1,0},
{0x3399,0x20,1,0},
};
OV2655_WREG <API key>[] =
{
//Contrast +1
{0x3391,0x04,1,0x04},
{0x3390,0x45,1,0x04},
{0x3398,0x24,1,0},
{0x3399,0x24,1,0},
};
OV2655_WREG <API key>[] =
{
//Contrast +2
{0x3391,0x04,1,0x04},
{0x3390,0x45,1,0x04},
{0x3398,0x28,1,0},
{0x3399,0x28,1,0},
};
OV2655_WREG <API key>[] =
{
//Contrast +3
{0x3391,0x04,1,0x04},
{0x3390,0x45,1,0x04},
{0x3398,0x2c,1,0},
{0x3399,0x2c,1,0},
};
OV2655_WREG <API key>[] =
{
//Contrast +4
{0x3391,0x04,1,0x04},
{0x3390,0x45,1,0x04},
{0x3398,0x30,1,0},
{0x3399,0x30,1,0},
};
OV2655_WREG <API key>[] =
{
//Sharpness 0
{0x3306,0x00,1,0x08},
{0x3376,0x01,1,0},
{0x3377,0x00,1,0},
{0x3378,0x10,1,0},
{0x3379,0x80,1,0},
};
OV2655_WREG <API key>[] =
{
//Sharpness 1
{0x3306,0x00,1,0x08},
{0x3376,0x02,1,0},
{0x3377,0x00,1,0},
{0x3378,0x08,1,0},
{0x3379,0x80,1,0},
};
OV2655_WREG <API key>[] =
{
//Sharpness_Auto (Default)
{0x3306,0x00,1,0x08},
{0x3376,0x05,1,0},//0x04
{0x3377,0x00,1,0},
{0x3378,0x04,1,0},
{0x3379,0x80,1,0},
};
OV2655_WREG <API key>[] =
{
//Sharpness 3
{0x3306,0x00,1,0x08},
{0x3376,0x06,1,0},
{0x3377,0x00,1,0},
{0x3378,0x04,1,0},
{0x3379,0x80,1,0},
};
OV2655_WREG <API key>[] =
{
//Sharpness 4
{0x3306,0x00,1,0x08},
{0x3376,0x08,1,0},
{0x3377,0x00,1,0},
{0x3378,0x04,1,0},
{0x3379,0x80,1,0},
};
OV2655_WREG <API key>[] =
{
//Sharpness 5
{0x3306,0x00,1,0x08},
{0x3376,0x0a,1,0},
{0x3377,0x00,1,0},
{0x3378,0x04,1,0},
{0x3379,0x80,1,0},
};
OV2655_WREG <API key>[] =
{
//Sharpness 5
{0x3306,0x00,1,0x08},
{0x3376,0x0c,1,0},
{0x3377,0x00,1,0},
{0x3378,0x04,1,0},
{0x3379,0x80,1,0},
};
OV2655_WREG <API key>[] =
{
//Sharpness 7
{0x3306,0x00,1,0x08},
{0x3376,0x0e,1,0},
{0x3377,0x00,1,0},
{0x3378,0x04,1,0},
{0x3379,0x80,1,0},
};
OV2655_WREG <API key>[] =
{
//Sharpness 8
{0x3306,0x00,1,0x08},
{0x3376,0x10,1,0},
{0x3377,0x00,1,0},
{0x3378,0x04,1,0},
{0x3379,0x80,1,0},
};
OV2655_WREG <API key>[] =
{
//Saturation x0.25
{0x3301,0x80,1,0x80},
{0x3391,0x02,1,0x02},
{0x3394,0x10,1,0},
{0x3395,0x10,1,0},
};
OV2655_WREG <API key>[] =
{
//Saturation x0.5
{0x3301,0x80,1,0x80},
{0x3391,0x02,1,0x02},
{0x3394,0x18,1,0},
{0x3395,0x18,1,0},
};
OV2655_WREG <API key>[] =
{
//Saturation x0.75
{0x3301,0x80,1,0x80},
{0x3391,0x02,1,0x02},
{0x3394,0x20,1,0},
{0x3395,0x20,1,0},
};
OV2655_WREG <API key>[] =
{
//Saturation x0.75
{0x3301,0x80,1,0x80},
{0x3391,0x02,1,0x02},
{0x3394,0x30,1,0},
{0x3395,0x30,1,0},
};
OV2655_WREG <API key>[] =
{
//Saturation x1 (Default)
{0x3301,0x80,1,0x80},
{0x3391,0x02,1,0x02},
{0x3394,0x40,1,0},
{0x3395,0x40,1,0},
};
OV2655_WREG <API key>[] =
{
//Saturation x1.25
{0x3301,0x80,1,0x80},
{0x3391,0x02,1,0x02},
{0x3394,0x50,1,0},
{0x3395,0x50,1,0},
};
OV2655_WREG <API key>[] =
{
//Saturation x1.5
{0x3301,0x80,1,0x80},
{0x3391,0x02,1,0x02},
{0x3394,0x58,1,0},
{0x3395,0x58,1,0},
};
OV2655_WREG <API key>[] =
{
//Saturation x1.25
{0x3301,0x80,1,0x80},
{0x3391,0x02,1,0x02},
{0x3394,0x60,1,0},
{0x3395,0x60,1,0},
};
OV2655_WREG <API key>[] =
{
//Saturation x1.5
{0x3301,0x80,1,0x80},
{0x3391,0x02,1,0x02},
{0x3394,0x68,1,0},
{0x3395,0x68,1,0},
};
OV2655_WREG <API key>[] =
{
//Brightness -4
{0x3391,0x04,1,0x04},
{0x3390,0x49,1,0x08},
{0x339a,0x28,1,0},
};
OV2655_WREG <API key>[] =
{
//Brightness -3
{0x3391,0x04,1,0x04},
{0x3390,0x49,1,0x08},
{0x339a,0x20,1,0},
};
OV2655_WREG <API key>[] =
{
//Brightness -2
{0x3391,0x04,1,0x04},
{0x3390,0x49,1,0x08},
{0x339a,0x18,1,0},
};
OV2655_WREG <API key>[] =
{
//Brightness -1
{0x3391,0x04,1,0x04},
{0x3390,0x49,1,0x08},
{0x339a,0x10,1,0},
};
OV2655_WREG <API key>[] =
{
//Brightness 0 (Default)
{0x3391,0x04,1,0x04},
{0x3390,0x41,1,0x08},
{0x339a,0x00,1,0},
};
OV2655_WREG <API key>[] =
{
//Brightness +1
{0x3391,0x04,1,0x04},
{0x3390,0x41,1,0x08},
{0x339a,0x10,1,0},
};
OV2655_WREG <API key>[] =
{
//Brightness +2
{0x3391,0x04,1,0x04},
{0x3390,0x41,1,0x08},
{0x339a,0x20,1,0},
};
OV2655_WREG <API key>[] =
{
//Brightness +3
{0x3391,0x04,1,0x04},
{0x3390,0x41,1,0x08},
{0x339a,0x28,1,0},
};
OV2655_WREG <API key>[] =
{
//Brightness +4
{0x3391,0x04,1,0x04},
{0x3390,0x41,1,0x08},
{0x339a,0x30,1,0},
};
OV2655_WREG <API key>[]=
{
//Exposure Compensation +1.7EV
{0x3018,0x98,1,0},
{0x3019,0x88,1,0},
{0x301a,0xd4,1,0},
};
OV2655_WREG <API key>[]=
{
//Exposure Compensation +1.0EV
{0x3018,0x88,1,0},
{0x3019,0x78,1,0},
{0x301a,0xd4,1,0},
};
OV2655_WREG <API key>[]=
{
//Exposure Compensation default
{0x3018,0x70,1,0},//0x78
{0x3019,0x60,1,0},//0x68
{0x301a,0x85,1,0},//0xa5
};
OV2655_WREG <API key>[]=
{
//Exposure Compensation -1.0EV
{0x3018,0x6a,1,0},
{0x3019,0x5a,1,0},
{0x301a,0xd4,1,0},
};
OV2655_WREG <API key>[]=
{
//Exposure Compensation -1.7EV
{0x3018,0x5a,1,0},
{0x3019,0x4a,1,0},
{0x301a,0xc2,1,0},
};
OV2655_WREG <API key>[]=
{
//ISO Auto
};
OV2655_WREG ov2655_iso_type_100[]=
{
//ISO 100
};
OV2655_WREG ov2655_iso_type_200[]=
{
//ISO 200
};
OV2655_WREG ov2655_iso_type_400[]=
{
//ISO 400
};
OV2655_WREG ov2655_iso_type_800[]=
{
//ISO 800
};
OV2655_WREG <API key>[]=
{
//ISO 1600
};
OV2655_WREG <API key>[] =
{
//Whole Image Average
{0x3030,0x55,1,0},
{0x3031,0x55,1,0},
{0x3032,0x55,1,0},
{0x3033,0x55,1,0},
};
OV2655_WREG <API key>[] =
{
//Whole Image Center More weight
{0x3030,0x00,1,0},
{0x3031,0x3c,1,0},
{0x3032,0x00,1,0},
{0x3033,0x00,1,0},
};
OV2655_WREG ov2655_wb_Auto[]=
{
//CAMERA_WB_AUTO //1
{0x3306,0x00,1,0x02},
};
OV2655_WREG ov2655_wb_custom[]=
{
//CAMERA_WB_CUSTOM //2
{0x3306,0x02,1,0x02},
{0x3337,0x44,1,0},
{0x3338,0x40,1,0},
{0x3339,0x70,1,0},
};
OV2655_WREG ov2655_wb_inc[]=
{
//<API key> //3
{0x3306,0x02,1,0x02},
{0x3337,0x52,1,0},
{0x3338,0x40,1,0},
{0x3339,0x58,1,0},
};
OV2655_WREG <API key>[]=
{
//<API key> //4
{0x3306,0x02,1,0x02},
{0x3337,0x44,1,0},
{0x3338,0x40,1,0},
{0x3339,0x70,1,0},
};
OV2655_WREG ov2655_wb_daylight[]=
{
//CAMERA_WB_DAYLIGHT //5
{0x3306,0x02,1,0x02},
{0x3337,0x5e,1,0},
{0x3338,0x40,1,0},
{0x3339,0x46,1,0},
};
OV2655_WREG ov2655_wb_cloudy[]=
{
//<API key> //6
// {0x3306,0x02,1,0x02},
// {0x3337,0x68,1,0},
// {0x3338,0x40,1,0},
// {0x3339,0x4e,1,0},
{0x3306,0x02,1,0x02},
{0x3337,0x78,1,0},
{0x3338,0x50,1,0},
{0x3339,0x48,1,0},
};
OV2655_WREG ov2655_wb_twilight[]=
{
//CAMERA_WB_TWILIGHT //7
};
OV2655_WREG ov2655_wb_shade[]=
{
//CAMERA_WB_SHADE //8
};
OV2655_WREG <API key>[] =
{
//CAMERA_EFFECT_OFF 0
{0x3391,0x00,1,0x78},
};
OV2655_WREG <API key>[] =
{
//CAMERA_EFFECT_MONO 1
{0x3391,0x20,1,0x78},
};
OV2655_WREG <API key>[] =
{
//<API key> 2
{0x3391,0x40,1,0x78},
};
OV2655_WREG <API key>[] =
{
//<API key> 3
};
OV2655_WREG <API key>[] =
{
//CAMERA_EFFECT_SEPIA 4
{0x3391,0x18,1,0x78},
{0x3396,0x40,1,0},
{0x3397,0xa6,1,0},
};
OV2655_WREG <API key>[] =
{
//<API key> 5
};
OV2655_WREG <API key>[] =
{
//<API key> 6
};
OV2655_WREG <API key>[] =
{
//<API key> 7
};
OV2655_WREG <API key>[] =
{
//CAMERA_EFFECT_AQUA 8
};
OV2655_WREG <API key>[] =
{
//CAMERA_EFFECT_BW 10
};
OV2655_WREG <API key>[] =
{
//<API key> 12
{0x3391,0x18,1,0x78},
{0x3396,0xa0,1,0},
{0x3397,0x40,1,0},
};
OV2655_WREG <API key>[] =
{
//<API key> 13
{0x3391,0x18,1,0x78},
{0x3396,0x80,1,0},
{0x3397,0xc0,1,0},
};
OV2655_WREG <API key>[] =
{
//<API key> 14
{0x3391,0x18,1,0x78},
{0x3396,0x60,1,0},
{0x3397,0x60,1,0},
};
OV2655_WREG <API key>[] =
{
//Auto-XCLK24MHz
// {0x3014,0xc0,1,0xc0},
{0x3014,0x80,1,0xc0},
};
OV2655_WREG <API key>[] =
{
//Band 50Hz
{0x3014,0x80,1,0xc0},
};
OV2655_WREG <API key>[] =
{
//Band 60Hz
// {0x3014,0x00,1,0xc0},
{0x3014,0x80,1,0xc0},
};
OV2655_WREG <API key>[] =
{
//Lens_shading On
{0x3300,0x08,1,0x08},
};
OV2655_WREG <API key>[] =
{
//Lens_shading Off
{0x3300,0x00,1,0x08},
};
OV2655_WREG ov2655_afinit_tbl[] =
{
};
#endif /* CAMSENSOR_OV2655 */
|
from django.db import models
from django.contrib.auth.models import User
class OrganisationType(models.Model):
type_desc = models.CharField(max_length=200)
def __unicode__(self):
return self.type_desc
class Address(models.Model):
street_address = models.CharField(max_length=100)
city = models.CharField(max_length=100)
pin = models.CharField(max_length=10)
province = models.CharField(max_length=100)
nationality = models.CharField(max_length=100)
def __unicode__(self):
return self.street_address + ',' + self.city
class HattiUser(models.Model):
user = models.OneToOneField(User)
address = models.ForeignKey(Address)
telephone = models.CharField(max_length=500)
date_joined = models.DateTimeField(auto_now_add=True)
fax = models.CharField(max_length=100)
avatar = models.CharField(max_length=100, null=True, blank=True)
tagline = models.CharField(max_length=140)
class Meta:
abstract = True
class AdminOrganisations(HattiUser):
title = models.CharField(max_length=200)
organisation_type = models.ForeignKey(OrganisationType)
def __unicode__(self):
return self.title
class Customer(HattiUser):
title = models.CharField(max_length=200, blank=True, null=True)
is_org = models.BooleanField();
org_type = models.ForeignKey(OrganisationType)
company = models.CharField(max_length = 200)
def __unicode__(self, arg):
return unicode(self.user)
|
#include "TestUnionJob.h"
#include "core/support/Debug.h"
#include "core/collections/CollectionLocation.h"
#include "synchronization/UnionJob.h"
#include "CollectionTestImpl.h"
#include "mocks/MockTrack.h"
#include "mocks/MockAlbum.h"
#include "mocks/MockArtist.h"
#include <KCmdLineArgs>
#include <KGlobal>
#include <QList>
#include <qtest_kde.h>
#include <gmock/gmock.h>
QTEST_KDEMAIN_CORE( TestUnionJob )
using ::testing::Return;
using ::testing::AnyNumber;
static QList<int> trackCopyCount;
namespace Collections {
class <API key> : public CollectionLocation
{
public:
Collections::CollectionTestImpl *coll;
QString prettyLocation() const { return "foo"; }
bool isWritable() const { return true; }
bool remove( const Meta::TrackPtr &track )
{
coll->mc->acquireWriteLock();
//theoretically we should clean up the other maps as well...
TrackMap map = coll->mc->trackMap();
map.remove( track->uidUrl() );
coll->mc->setTrackMap( map );
coll->mc->releaseLock();
return true;
}
void <API key>(const QMap<Meta::TrackPtr, KUrl> &sources, const Transcoding::Configuration& conf)
{
Q_UNUSED( conf )
trackCopyCount << sources.count();
foreach( const Meta::TrackPtr &track, sources.keys() )
{
coll->mc->addTrack( track );
}
}
};
class <API key> : public CollectionTestImpl
{
public:
<API key>( const QString &id ) : CollectionTestImpl( id ) {}
CollectionLocation* location() const
{
<API key> *r = new <API key>();
r->coll = const_cast<<API key>*>( this );
return r;
}
};
} //namespace Collections
void addMockTrack( Collections::CollectionTestImpl *coll, const QString &trackName, const QString &artistName, const QString &albumName )
{
Meta::MockTrack *track = new Meta::MockTrack();
::testing::Mock::AllowLeak( track );
Meta::TrackPtr trackPtr( track );
EXPECT_CALL( *track, name() ).Times( AnyNumber() ).WillRepeatedly( Return( trackName ) );
EXPECT_CALL( *track, uidUrl() ).Times( AnyNumber() ).WillRepeatedly( Return( trackName + "_" + artistName + "_" + albumName ) );
EXPECT_CALL( *track, isPlayable() ).Times( AnyNumber() ).WillRepeatedly( Return( true ) );
EXPECT_CALL( *track, playableUrl() ).Times( AnyNumber() ).WillRepeatedly( Return( KUrl( '/' + track->uidUrl() ) ) );
coll->mc->addTrack( trackPtr );
Meta::AlbumPtr albumPtr = coll->mc->albumMap().value( albumName );
Meta::MockAlbum *album;
Meta::TrackList albumTracks;
if( albumPtr )
{
album = dynamic_cast<Meta::MockAlbum*>( albumPtr.data() );
if( !album )
{
QFAIL( "expected a Meta::MockAlbum" );
return;
}
albumTracks = albumPtr->tracks();
}
else
{
album = new Meta::MockAlbum();
::testing::Mock::AllowLeak( album );
albumPtr = Meta::AlbumPtr( album );
EXPECT_CALL( *album, name() ).Times( AnyNumber() ).WillRepeatedly( Return( albumName ) );
EXPECT_CALL( *album, hasAlbumArtist() ).Times( AnyNumber() ).WillRepeatedly( Return( false ) );
EXPECT_CALL( *album, albumArtist() ).Times( AnyNumber() ).WillRepeatedly( Return( Meta::ArtistPtr() ) );
coll->mc->addAlbum( albumPtr );
}
albumTracks << trackPtr;
EXPECT_CALL( *album, tracks() ).Times( AnyNumber() ).WillRepeatedly( Return( albumTracks ) );
EXPECT_CALL( *track, album() ).Times( AnyNumber() ).WillRepeatedly( Return( albumPtr ) );
Meta::ArtistPtr artistPtr = coll->mc->artistMap().value( artistName );
Meta::MockArtist *artist;
Meta::TrackList artistTracks;
if( artistPtr )
{
artist = dynamic_cast<Meta::MockArtist*>( artistPtr.data() );
if( !artist )
{
QFAIL( "expected a Meta::MockArtist" );
return;
}
artistTracks = artistPtr->tracks();
}
else
{
artist = new Meta::MockArtist();
::testing::Mock::AllowLeak( artist );
artistPtr = Meta::ArtistPtr( artist );
EXPECT_CALL( *artist, name() ).Times( AnyNumber() ).WillRepeatedly( Return( artistName ) );
coll->mc->addArtist( artistPtr );
}
artistTracks << trackPtr;
EXPECT_CALL( *artist, tracks() ).Times( AnyNumber() ).WillRepeatedly( Return( artistTracks ) );
EXPECT_CALL( *track, artist() ).Times( AnyNumber() ).WillRepeatedly( Return( artistPtr ) );
}
TestUnionJob::TestUnionJob() : QObject()
{
KCmdLineArgs::init( KGlobal::activeComponent().aboutData() );
::testing::InitGoogleMock( &KCmdLineArgs::qtArgc(), KCmdLineArgs::qtArgv() );
qRegisterMetaType<Meta::TrackList>();
qRegisterMetaType<Meta::AlbumList>();
qRegisterMetaType<Meta::ArtistList>();
}
void
TestUnionJob::init()
{
trackCopyCount.clear();
}
void
TestUnionJob::testEmptyA()
{
Collections::CollectionTestImpl *collA = new Collections::<API key>("A");
Collections::CollectionTestImpl *collB = new Collections::<API key>("B");
addMockTrack( collB, "track1", "artist1", "album1" );
QCOMPARE( collA->mc->trackMap().count(), 0 );
QCOMPARE( collB->mc->trackMap().count(), 1 );
QVERIFY( trackCopyCount.isEmpty() );
UnionJob *job = new UnionJob( collA, collB );
job->synchronize();
QTest::kWaitForSignal( job, SIGNAL(destroyed()), 1000 );
QCOMPARE( trackCopyCount.size(), 1 );
QVERIFY( trackCopyCount.contains( 1 ) );
QCOMPARE( collA->mc->trackMap().count(), 1 );
QCOMPARE( collB->mc->trackMap().count(), 1 );
delete collA;
delete collB;
}
void
TestUnionJob::testEmptyB()
{
Collections::CollectionTestImpl *collA = new Collections::<API key>("A");
Collections::CollectionTestImpl *collB = new Collections::<API key>("B");
addMockTrack( collA, "track1", "artist1", "album1" );
QCOMPARE( collA->mc->trackMap().count(), 1 );
QCOMPARE( collB->mc->trackMap().count(), 0 );
QVERIFY( trackCopyCount.isEmpty() );
UnionJob *job = new UnionJob( collA, collB );
job->synchronize();
QTest::kWaitForSignal( job, SIGNAL(destroyed()), 1000 );
QCOMPARE( trackCopyCount.size(), 1 );
QVERIFY( trackCopyCount.contains( 1 ) );
QCOMPARE( collA->mc->trackMap().count(), 1 );
QCOMPARE( collB->mc->trackMap().count(), 1 );
delete collA;
delete collB;
}
void
TestUnionJob::testAddTrackToBoth()
{
Collections::CollectionTestImpl *collA = new Collections::<API key>("A");
Collections::CollectionTestImpl *collB = new Collections::<API key>("B");
addMockTrack( collA, "track1", "artist1", "album1" );
addMockTrack( collB, "track2", "artist2", "album2" );
QCOMPARE( collA->mc->trackMap().count(), 1 );
QCOMPARE( collB->mc->trackMap().count(), 1 );
QVERIFY( trackCopyCount.isEmpty() );
UnionJob *job = new UnionJob( collA, collB );
job->synchronize();
QTest::kWaitForSignal( job, SIGNAL(destroyed()), 1000 );
QCOMPARE( trackCopyCount.size(), 2 );
QCOMPARE( trackCopyCount.at( 0 ), 1 );
QCOMPARE( trackCopyCount.at( 1 ), 1 );
QCOMPARE( collA->mc->trackMap().count(), 2 );
QCOMPARE( collB->mc->trackMap().count(), 2 );
delete collA;
delete collB;
}
void
TestUnionJob::<API key>()
{
Collections::CollectionTestImpl *collA = new Collections::<API key>("A");
Collections::CollectionTestImpl *collB = new Collections::<API key>("B");
addMockTrack( collA, "track1", "artist1", "album1" );
addMockTrack( collB, "track1", "artist1", "album1" );
addMockTrack( collB, "track2", "artist2", "album2" );
QCOMPARE( collA->mc->trackMap().count(), 1 );
QCOMPARE( collB->mc->trackMap().count(), 2 );
QVERIFY( trackCopyCount.isEmpty() );
UnionJob *job = new UnionJob( collA, collB );
job->synchronize();
QTest::kWaitForSignal( job, SIGNAL(destroyed()), 1000 );
QCOMPARE( trackCopyCount.size(), 1 );
QVERIFY( trackCopyCount.contains( 1 ) );
QCOMPARE( collA->mc->trackMap().count(), 2 );
QCOMPARE( collB->mc->trackMap().count(), 2 );
delete collA;
delete collB;
}
|
#include "StdAfx.h"
#include <commands/<API key>.h>
#include "../UIMApplication.h"
<API key>::<API key>()
{
}
<API key>::~<API key>(void)
{
}
void <API key>::Execute()
{
CUIMApplication::GetApplication()->GetUIManager()-><API key>(NULL);
}
|
#pragma once
#include "FileItem.h"
#include "PVRChannelGroup.h"
#include "threads/CriticalSection.h"
namespace PVR
{
/** A container class for channel groups */
class CPVRChannelGroups
{
public:
/*!
* @brief Create a new group container.
* @param bRadio True if this is a container for radio channels, false if it is for tv channels.
*/
CPVRChannelGroups(bool bRadio);
virtual ~CPVRChannelGroups(void);
/*!
* @brief Remove all channels from this group.
*/
void Clear(void);
/*!
* @brief Load this container's contents from the database or PVR clients.
* @return True if it was loaded successfully, false if not.
*/
bool Load(void);
/*!
* @return Amount of groups in this container
*/
int Size(void) const { CSingleLock lock(m_critSection); return m_groups.size(); }
/*!
* @brief Update a group or add it if it's not in here yet.
* @param group The group to update.
* @param bSaveInDb True to save the changes in the db.
* @return True if the group was added or update successfully, false otherwise.
*/
bool Update(const CPVRChannelGroup &group, bool bSaveInDb = false);
/*!
* @brief Called by the add-on callback to add a new group
* @param group The group to add
* @return True when updated, false otherwise
*/
bool UpdateFromClient(const CPVRChannelGroup &group) { return Update(group, false); }
/*!
* @brief Get a channel given it's path
* @param strPath The path to the channel
* @return The channel, or an empty fileitem when not found
*/
CFileItemPtr GetByPath(const CStdString &strPath) const;
/*!
* @brief Get a pointer to a channel group given it's ID.
* @param iGroupId The ID of the group.
* @return The group or NULL if it wasn't found.
*/
CPVRChannelGroupPtr GetById(int iGroupId) const;
/*!
* @brief Get a group given it's name.
* @param strName The name.
* @return The group or NULL if it wan't found.
*/
CPVRChannelGroupPtr GetByName(const CStdString &strName) const;
/*!
* @brief Get the group that contains all channels.
* @return The group that contains all channels.
*/
CPVRChannelGroupPtr GetGroupAll(void) const;
/*!
* @brief Get the list of groups.
* @param results The file list to store the results in.
* @return The amount of items that were added.
*/
int GetGroupList(CFileItemList* results) const;
/*!
* @brief Get the previous group in this container.
* @param group The current group.
* @return The previous group or the group containing all channels if it wasn't found.
*/
CPVRChannelGroupPtr GetPreviousGroup(const CPVRChannelGroup &group) const;
/*!
* @brief Get the next group in this container.
* @param group The current group.
* @return The next group or the group containing all channels if it wasn't found.
*/
CPVRChannelGroupPtr GetNextGroup(const CPVRChannelGroup &group) const;
/*!
* @brief Get the group that is currently selected in the UI.
* @return The selected group.
*/
CPVRChannelGroupPtr GetSelectedGroup(void) const;
/*!
* @brief Change the selected group.
* @param group The group to select.
*/
void SetSelectedGroup(CPVRChannelGroupPtr group);
/*!
* @brief Add a group to this container.
* @param strName The name of the group.
* @return True if the group was added, false otherwise.
*/
bool AddGroup(const CStdString &strName);
/*!
* @brief Delete a group in this container.
* @param group The group to delete.
* @return True if it was deleted successfully, false if not.
*/
bool DeleteGroup(const CPVRChannelGroup &group);
/*!
* @brief Remove a channel from all non-system groups.
* @param channel The channel to remove.
*/
void RemoveFromAllGroups(const CPVRChannel &channel);
/*!
* @brief Persist all changes in channel groups.
* @return True if everything was persisted, false otherwise.
*/
bool PersistAll(void);
/*!
* @return True when this container contains radio groups, false otherwise
*/
bool IsRadio(void) const { return m_bRadio; }
/*!
* @brief Call by a guiwindow/dialog to add the groups to a control
* @param iWindowId The window to add the groups to.
* @param iControlId The control to add the groups to
*/
void FillGroupsGUI(int iWindowId, int iControlId) const;
/*!
* @brief Update the contents of the groups in this container.
* @param bChannelsOnly Set to true to only update channels, not the groups themselves.
* @return True if the update was successful, false otherwise.
*/
bool Update(bool bChannelsOnly = false);
private:
bool UpdateGroupsEntries(const CPVRChannelGroups &groups);
bool <API key>(void);
bool <API key>(void);
bool m_bRadio; /*!< true if this is a container for radio channels, false if it is for tv channels */
CPVRChannelGroupPtr m_selectedGroup; /*!< the group that's currently selected in the UI */
std::vector<CPVRChannelGroupPtr> m_groups; /*!< the groups in this container */
CCriticalSection m_critSection;
};
}
|
#include "Log.h"
#include "ObjectAccessor.h"
#include "CreatureAI.h"
#include "ObjectMgr.h"
#include "TemporarySummon.h"
TempSummon::TempSummon(<API key> const *properties, Unit *owner) :
Creature(), m_Properties(properties), m_type(<API key>),
m_timer(0), m_lifetime(0)
{
m_summonerGUID = owner ? owner->GetGUID() : 0;
m_unitTypeMask |= UNIT_MASK_SUMMON;
}
Unit* TempSummon::GetSummoner() const
{
return m_summonerGUID ? ObjectAccessor::GetUnit(*this, m_summonerGUID) : NULL;
}
void TempSummon::Update(uint32 diff)
{
Creature::Update(diff);
if (m_deathState == DEAD)
{
UnSummon();
return;
}
switch(m_type)
{
case <API key>:
break;
case <API key>:
{
if (m_timer <= diff)
{
UnSummon();
return;
}
m_timer -= diff;
break;
}
case <API key>:
{
if (!isInCombat())
{
if (m_timer <= diff)
{
UnSummon();
return;
}
m_timer -= diff;
}
else if (m_timer != m_lifetime)
m_timer = m_lifetime;
break;
}
case <API key>:
{
if (m_deathState == CORPSE)
{
if (m_timer <= diff)
{
UnSummon();
return;
}
m_timer -= diff;
}
break;
}
case <API key>:
{
// if m_deathState is DEAD, CORPSE was skipped
if (m_deathState == CORPSE || m_deathState == DEAD)
{
UnSummon();
return;
}
break;
}
case <API key>:
{
if (m_deathState == DEAD)
{
UnSummon();
return;
}
break;
}
case <API key>:
{
// if m_deathState is DEAD, CORPSE was skipped
if (m_deathState == CORPSE || m_deathState == DEAD)
{
UnSummon();
return;
}
if (!isInCombat())
{
if (m_timer <= diff)
{
UnSummon();
return;
}
else
m_timer -= diff;
}
else if (m_timer != m_lifetime)
m_timer = m_lifetime;
break;
}
case <API key>:
{
// if m_deathState is DEAD, CORPSE was skipped
if (m_deathState == DEAD)
{
UnSummon();
return;
}
if (!isInCombat() && isAlive())
{
if (m_timer <= diff)
{
UnSummon();
return;
}
else
m_timer -= diff;
}
else if (m_timer != m_lifetime)
m_timer = m_lifetime;
break;
}
default:
UnSummon();
sLog->outError("Temporary summoned creature (entry: %u) have unknown type %u of ", GetEntry(), m_type);
break;
}
}
void TempSummon::InitStats(uint32 duration)
{
ASSERT(!isPet());
m_timer = duration;
m_lifetime = duration;
if (m_type == <API key>)
m_type = (duration == 0) ? <API key> : <API key>;
Unit *owner = GetSummoner();
if (owner && isTrigger() && m_spells[0])
{
setFaction(owner->getFaction());
SetLevel(owner->getLevel());
if (owner->GetTypeId() == TYPEID_PLAYER)
<API key> = true;
}
if (!m_Properties)
return;
if (owner)
{
if (uint32 slot = m_Properties->Slot)
{
if (owner->m_SummonSlot[slot] && owner->m_SummonSlot[slot] != GetGUID())
{
Creature *oldSummon = GetMap()->GetCreature(owner->m_SummonSlot[slot]);
if (oldSummon && oldSummon->isSummon())
oldSummon->ToTempSummon()->UnSummon();
}
owner->m_SummonSlot[slot] = GetGUID();
}
}
if (m_Properties->Faction)
setFaction(m_Properties->Faction);
else if (IsVehicle()) // properties should be vehicle
setFaction(owner->getFaction());
}
void TempSummon::InitSummon()
{
Unit* owner = GetSummoner();
if (owner)
{
if (owner->GetTypeId() == TYPEID_UNIT && owner->ToCreature()->IsAIEnabled)
owner->ToCreature()->AI()->JustSummoned(this);
if (IsAIEnabled)
AI()->IsSummonedBy(owner);
}
}
void TempSummon::SetTempSummonType(TempSummonType type)
{
m_type = type;
}
void TempSummon::UnSummon(uint32 msTime)
{
if (msTime)
{
<API key> *pEvent = new <API key>(*this);
m_Events.AddEvent(pEvent, m_Events.CalculateTime(msTime));
return;
}
//ASSERT(!isPet());
if (isPet())
{
((Pet*)this)->Remove(<API key>);
ASSERT(!IsInWorld());
return;
}
Unit* owner = GetSummoner();
if (owner && owner->GetTypeId() == TYPEID_UNIT && owner->ToCreature()->IsAIEnabled)
owner->ToCreature()->AI()-><API key>(this);
if (owner &&
owner->GetTypeId() == TYPEID_PLAYER &&
((Player*)owner)->HaveBot() &&
((Player*)owner)->GetBot()->GetGUID()==this->GetGUID() &&
this->isDead()) { // dont unsummon corpse if a bot
return;
}
<API key>();
}
bool <API key>::Execute(uint64 /*e_time*/, uint32 /*p_time*/)
{
m_owner.UnSummon();
return true;
}
void TempSummon::RemoveFromWorld()
{
if (!IsInWorld())
return;
if (m_Properties)
if (uint32 slot = m_Properties->Slot)
if (Unit* owner = GetSummoner())
if (owner->m_SummonSlot[slot] == GetGUID())
owner->m_SummonSlot[slot] = 0;
//if (GetOwnerGUID())
// sLog->outError("Unit %u has owner guid when removed from world", GetEntry());
Creature::RemoveFromWorld();
}
Minion::Minion(<API key> const *properties, Unit *owner) : TempSummon(properties, owner)
, m_owner(owner)
{
ASSERT(m_owner);
m_unitTypeMask |= UNIT_MASK_MINION;
m_followAngle = PET_FOLLOW_ANGLE;
}
void Minion::InitStats(uint32 duration)
{
TempSummon::InitStats(duration);
SetReactState(REACT_PASSIVE);
SetCreatorGUID(m_owner->GetGUID());
setFaction(m_owner->getFaction());
m_owner->SetMinion(this, true);
}
void Minion::RemoveFromWorld()
{
if (!IsInWorld())
return;
m_owner->SetMinion(this, false);
TempSummon::RemoveFromWorld();
}
bool Minion::IsGuardianPet() const
{
return isPet() || (m_Properties && m_Properties->Category == SUMMON_CATEGORY_PET);
}
Guardian::Guardian(<API key> const *properties, Unit *owner) : Minion(properties, owner)
, m_bonusSpellDamage(0)
{
memset(m_statFromOwner, 0, sizeof(float)*MAX_STATS);
m_unitTypeMask |= UNIT_MASK_GUARDIAN;
if (properties && properties->Type == SUMMON_TYPE_PET)
{
m_unitTypeMask |= <API key>;
InitCharmInfo();
}
}
void Guardian::InitStats(uint32 duration)
{
Minion::InitStats(duration);
InitStatsForLevel(m_owner->getLevel());
if (m_owner->GetTypeId() == TYPEID_PLAYER && HasUnitTypeMask(<API key>))
m_charmInfo-><API key>();
SetReactState(REACT_AGGRESSIVE);
}
void Guardian::InitSummon()
{
TempSummon::InitSummon();
if (m_owner->GetTypeId() == TYPEID_PLAYER
&& m_owner->GetMinionGUID() == GetGUID()
&& !m_owner->GetCharmGUID())
m_owner->ToPlayer()-><API key>();
}
Puppet::Puppet(<API key> const *properties, Unit *owner) : Minion(properties, owner)
{
ASSERT(owner->GetTypeId() == TYPEID_PLAYER);
m_owner = (Player*)owner;
m_unitTypeMask |= UNIT_MASK_PUPPET;
}
void Puppet::InitStats(uint32 duration)
{
Minion::InitStats(duration);
SetLevel(m_owner->getLevel());
SetReactState(REACT_PASSIVE);
}
void Puppet::InitSummon()
{
Minion::InitSummon();
if (!SetCharmedBy(m_owner, CHARM_TYPE_POSSESS))
ASSERT(false);
}
void Puppet::Update(uint32 time)
{
Minion::Update(time);
//check if caster is channelling?
if (IsInWorld())
{
if (!isAlive())
{
UnSummon();
// TODO: why long distance .die does not remove it
}
}
}
void Puppet::RemoveFromWorld()
{
if (!IsInWorld())
return;
RemoveCharmedBy(NULL);
Minion::RemoveFromWorld();
}
|
CREATE TABLE `wp_term_taxonomy` (
`term_taxonomy_id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
`term_id` bigint(20) unsigned NOT NULL DEFAULT '0',
`taxonomy` varchar(32) NOT NULL DEFAULT '',
`description` longtext NOT NULL,
`parent` bigint(20) unsigned NOT NULL DEFAULT '0',
`count` bigint(20) NOT NULL DEFAULT '0',
PRIMARY KEY (`term_taxonomy_id`),
UNIQUE KEY `term_id_taxonomy` (`term_id`,`taxonomy`),
KEY `taxonomy` (`taxonomy`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8
|
#ifndef ZABBIX_HISTORY_H
#define ZABBIX_HISTORY_H
#define <API key> 0
#define <API key> 1
typedef struct zbx_history_iface zbx_history_iface_t;
typedef void (*<API key>)(struct zbx_history_iface *hist);
typedef int (*<API key>)(struct zbx_history_iface *hist, const zbx_vector_ptr_t *history);
typedef int (*<API key>)(struct zbx_history_iface *hist, zbx_uint64_t itemid, int start,
int count, int end, <API key> *values);
typedef void (*<API key>)(struct zbx_history_iface *hist);
struct zbx_history_iface
{
unsigned char value_type;
unsigned char requires_trends;
void *data;
<API key> destroy;
<API key> add_values;
<API key> get_values;
<API key> flush;
};
/* SQL hist */
int <API key>(zbx_history_iface_t *hist, unsigned char value_type, char **error);
/* elastic hist */
int <API key>(zbx_history_iface_t *hist, unsigned char value_type, char **error);
#endif
|
package com.orange.documentare.core.comp.clustering.tasksservice;
import com.orange.documentare.core.comp.clustering.graph.<API key>;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.FileUtils;
import org.fest.assertions.Assertions;
import org.junit.After;
import org.junit.Test;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
@Slf4j
public class <API key> {
private static final int NB_TASKS = 4 * 10;
private static final String <API key> = "clustering_tasks_";
private static final String <API key> = "stripped_clustering.json";
private static final String <API key> = "<API key>.json";
private final <API key> tasksHandler = <API key>.instance();
private final <API key> parameters = <API key>.builder().acut().qcut().build();
@After
public void cleanup() {
FileUtils.deleteQuietly(new File(<API key>));
FileUtils.deleteQuietly(new File(<API key>));
}
@Test
public void <API key>() throws IOException, <API key> {
// given
String refJson1 = FileUtils.readFileToString(new File(getClass().getResource("/clusteringtasks/latin1_clustering.ref.json").getFile()));
String refJson2 = FileUtils.readFileToString(new File(getClass().getResource("/clusteringtasks/latin2_clustering.ref.json").getFile()));
String refJson3 = FileUtils.readFileToString(new File(getClass().getResource("/clusteringtasks/latin3_clustering.ref.json").getFile()));
String refJson4 = FileUtils.readFileToString(new File(getClass().getResource("/clusteringtasks/latin4_clustering.ref.json").getFile()));
File segFile1 = new File(getClass().getResource("/clusteringtasks/latin1_segmentation.json").getFile());
File segFile2 = new File(getClass().getResource("/clusteringtasks/latin2_segmentation.json").getFile());
File segFile3 = new File(getClass().getResource("/clusteringtasks/latin3_segmentation.json").getFile());
File segFile4 = new File(getClass().getResource("/clusteringtasks/latin4_segmentation.json").getFile());
String[] outputFilenames = new String[NB_TASKS];
ClusteringTask[] clusteringTasks = new ClusteringTask[NB_TASKS];
for (int i = 0; i < NB_TASKS; i++) {
outputFilenames[i] = <API key> + i + ".json";
}
for (int i = 0; i < NB_TASKS/4; i++) {
clusteringTasks[i * 4] = ClusteringTask.builder()
.inputFilename(segFile1.getAbsolutePath())
.outputFilename(outputFilenames[i * 4])
.<API key>(parameters)
.build();
clusteringTasks[i * 4 + 1] = ClusteringTask.builder()
.inputFilename(segFile2.getAbsolutePath())
.outputFilename(outputFilenames[i * 4 + 1])
.<API key>(parameters)
.build();
clusteringTasks[i * 4 + 2] = ClusteringTask.builder()
.inputFilename(segFile3.getAbsolutePath())
.outputFilename(outputFilenames[i * 4 + 2])
.<API key>(parameters)
.build();
clusteringTasks[i * 4 + 3] = ClusteringTask.builder()
.inputFilename(segFile4.getAbsolutePath())
.outputFilename(outputFilenames[i * 4 + 3])
.<API key>(parameters)
.build();
}
// when
for (int i = 0; i < NB_TASKS; i++) {
tasksHandler.addNewTask(clusteringTasks[i]);
Thread.sleep(200);
log.info(tasksHandler.tasksDescription().toString());
}
tasksHandler.waitForAllTasksDone();
String[] outputJsons = new String[NB_TASKS];
for (int i = 0; i < NB_TASKS; i++) {
outputJsons[i] = FileUtils.readFileToString(new File(outputFilenames[i]));
}
// then
for (int i = 0; i < NB_TASKS/4; i++) {
Assertions.assertThat(outputJsons[i * 4]).isEqualTo(refJson1);
Assertions.assertThat(outputJsons[i * 4 + 1]).isEqualTo(refJson2);
Assertions.assertThat(outputJsons[i * 4 + 2]).isEqualTo(refJson3);
Assertions.assertThat(outputJsons[i * 4 + 3]).isEqualTo(refJson4);
}
Arrays.stream(outputFilenames)
.forEach(f -> FileUtils.deleteQuietly(new File(f)));
}
@Test
public void saveStrippedOutput() throws IOException, <API key> {
// given
File ref = new File(getClass().getResource("/clusteringtasks/stripped_clustering.ref.json").getFile());
String jsonRef = FileUtils.readFileToString(ref);
String strippedFilename = <API key>;
File strippedFile = new File(strippedFilename);
strippedFile.delete();
File segFile = new File(getClass().getResource("/clusteringtasks/latin1_segmentation.json").getFile());
String outputFilename = <API key>;
ClusteringTask task = ClusteringTask.builder()
.inputFilename(segFile.getAbsolutePath())
.outputFilename(outputFilename)
.<API key>(parameters)
.<API key>(strippedFilename)
.build();
// when
tasksHandler.addNewTask(task);
tasksHandler.waitForAllTasksDone();
// then
String strippedJson = FileUtils.readFileToString(strippedFile);
Assertions.assertThat(strippedFile).exists();
Assertions.assertThat(strippedJson).isEqualTo(jsonRef);
}
}
|
.head_title {
text-align: center;
font-size: 20px;
color:#002529;
font-weight: 400;
position:relative;
}
.head_title:after{content: ''; position: absolute;left: 0;top:30px; background:#cacaca; width: 100%;height: 1px;
-webkit-transform: scaleY(0.5);transform: scaleY(0.5);-<API key>: 0 0;transform-origin: 0 0; }
.weui-search-bar,.<API key>{background-color:#fff;}
.<API key>{text-align: left;margin:0 10px;}
.weui-search-bar:before{border-top:none;}
.weui-search-bar:after{border-bottom:none;}
.swiper-container {
width: 100%;
height: 100%;
}
.swiper-container img{width:100%;height:100%;}
.btn_libao{margin:10px 36px; height: auto; overflow: hidden;}
.btn_libao img{width:100%; height:100%; max-width: 100%; }
.bar_square{margin:10px 0; }
.bar_square:before, .bar_square:after,.bar_square .weui-grid:before{border:none;}
.bar_square .weui-grid__icon{width:45px;height: 50px;}
.bar_square .weui-footer, .weui-grid__label{font-size:16px;}
.song_left{ width:50%; padding-right:5px;}
.song_left img{width:100%; max-width: 100%;}
.song_right{width:50%;}
.song_right img{width:100%; max-width: 100%;}
.demos-title {
text-align: center;
font-size:30px;
color: #2b2b2b;
font-weight: 400;
margin: 0 15%;
}
.demos-sub-title {
text-align: center;
color: #2b2b2b;
font-size: 14px;
}
.demos-header {
position:relative;
margin:25px 0;
}
.demos_right_ico{position:absolute; right:25px;top:30px;}
.demos_right_ico:after{
content: " ";
display: inline-block;
height: 12px;
width: 12px;
border-width: 2px 2px 0 0;
border-color: #c8c8cd;
border-style: solid;
-webkit-transform: matrix(.71,.71,-.71,.71,0,0);
transform: matrix(.71,.71,-.71,.71,0,0);
position: relative;
position: absolute;
right: 2px;
}
.flavor{padding-bottom:5px;}
.flavor .weui-grid__icon{width:100%;height: 100%;}
.hot_buy{margin:20px 0 80px; height: auto; overflow: hidden; padding:0 2%;}
.hot_buy li{float: left; list-style: none; width:48%;margin:0 1%; text-align: center; margin-bottom:20px;}
.hot_buy img{width:100%;height:100%;}
.hot_buy .p1{color: #222222; font-size:16px; font-weight: bolder;}
.hot_buy .p2{color: #494949; font-size:14px;}
.hot_buy .p3{color: #f4392d; font-size:16px;}
.weui-tabbar{position:fixed;}
.weui-tabbar__item .weui-tabbar__label{color:#252525;}
.weui-tabbar__item.active .weui-tabbar__label{color:#ff2d2d;}
.active i{color:#ff2d2d;}
.news_list li{
box-sizing: border-box;
border:1px solid #eaeaea;
text-align:left;
height: auto;
overflow: hidden;
}
.news_list li p{padding:0 5px;line-height: 26px;}
.news_list li .p2{color: #666666;}
.news_list li .p3 span{color:#b8b8b8; text-decoration: line-through; padding-left:15px;}
.news_list li .p4{font-size:12px; color:#b8b8b8; padding:5px 5px;}
.type-tab{border-top:1px solid #eee;}
.type_left{float: left;width:30%;position:inherit;display: block; background:#fff;}
.type_left .weui-navbar__item{width:100%;height: auto;overflow: hidden;}
.type_left .weui-navbar__item:after{border-right:none;}
.type_left:after{border-bottom:none;}
.type_right{float:left; width:70%; border-left: 1px solid #eee;min-height: 500px;}
.weui-navbar+.type_right{padding-top:0;}
.type_right .rqtj_list .p_title{font-size:13px; color: #636363;}
.type_right .rqtj_list .p_price{font-size:13px; color:red; text-align: center;}
.pinpai_list li{
list-style: none;
width:31%;
box-sizing: border-box;
padding:0 5px;
border:1px solid #eee;
border-radius: 2px;
}
.pinpai_list li .p_title{text-align: center; font-size:13px; color: #636363;margin-bottom:5px;}
.type_renqun{width:80%;margin:0 10%;}
.type_renqun li{list-style: none; width:100%;}
.type_renqun li img{width:100%;height: 100%;}
.type_right .hot_buy{margin:0 0 80px;}
.type_right .p_biaoti{text-align: center; margin:15px 0; color: #adadad;font-size:13px;}
.type_right .p_biaoti span{color: #eaeaea;}
.nav_info{
background-color:#ec3e36; height:120px;width:100%;
}
.nav_info img{width:50px;height: 50px; border-radius: 50%; border:2px solid #fff; float: left; margin:20px ;}
.nav_info p{color: #fff; font-size: 18px; padding-top:40px;}
.cells_setall{padding-bottom:10px;font-size:16px;}
.cells_setall:before{border:none;}
.weui-cells:after{bottom:1px;}
.user_navlist{text-align: center; color:#938e8e;margin:15px 0}
.user_navlist i{color:#938e8e}
.div_gray{width:100%;height:10px; background: #eeeeee;}
.user_list p{color: #444;}
.user_list:before{border:none;}
/*three.html */
.three_pageinfo{padding:10px;}
.three_pageinfo .p1{color: #373b41;font-size:18px;}
.three_pageinfo .p1 span{background: #66d8d6;display:inline-block;font-size:14px; padding:1px 5px;border-radius: 5px; margin-left: 10px; color:#fff;}
.three_pageinfo .p2{color: #b8b8b8;font-size:16px;margin-top:5px;}
.three_pageinfo .p3{color: #f44236;font-size:18px;font-weight: bolder; margin-top:10px;}
.three_pageinfo .p3 span{display: inline-block;text-decoration: line-through;color: #b8b8b8;margin-left:15px;}
.three_pageinfo .p4{color: #f44236;font-size:16px;border-top:1px solid #eee;margin-top:10px;padding:5px 0;}
.three_guige{margin:10px 0;}
.three_guige p{color:#b8b8b8;font-size:14px;}
.three_guige p span{color:#000000;font-size:14px;margin-left:15px;}
.three_guige:before,.three_guige:after{border:None;}
.three_guige .weui-cell_access .weui-cell__ft:after{border-color:#000000;width:10px;height: 10px;border-width: 1px 1px 0 0;}
.evaluate .weui-cell__bd{color:#b8b8b8}
.evaluate .weui-cell__bd span{display: inline-block;margin-left: 10px; color:#373b41}
.evaluate .weui-cell__bd label{color:red;}
.three_imglist{margin:10px 0 80px; padding:0 10px;}
.three_imglist p{color:#b8b8b8;margin:5px 0;}
.three_imglist img{width:100%;height: 100%;}
.placeholder {
margin: 5px 10px;
padding: 0 20px;
text-align: center;
color: #cfcfcf;
}
.buy_button{display: block; background: #ff3939}
.buy_button .weui-tabbar__item .weui-tabbar__label{color:#fff;font-size:16px;padding-top:10px;}
.buy_wintop{margin:20px 0; height: auto;overflow: hidden;}
.buy_wintop img{float: left; width:50px; height: 50px;margin-left:20px;}
.buy_wintop .div_right{float: left;font-size:14px;margin-left:15px;}
.buy_wintop .p2{color:#f44236;font-size:12px;font-weight: bolder;}
.buy_wintop .p3{color:#b8b8b8;font-size:12px;}
.buy_winmiddle{padding:10px 20px;width:100%;height: auto; overflow: hidden;color: #000;}
.buy_winmiddle span{display: inline-block;margin:10px 5px 0; border-radius: 3px; border:1px solid #666; width:40%;text-align: center;}
.buy_winmiddle .active{border:1px solid #f44236;color: #f44236;}
.buy_bottom p{float: left;}
.<API key>{height: auto;overflow: hidden; text-align: left;padding: 0;}
.<API key>{display: none;}
.gw_num{float:left; margin-left:43%;border: 1px solid #dbdbdb; line-height: 26px;overflow: hidden;}
.gw_num em{display: block;height: 26px;width: 26px;float:left;color: #7A7979;border-right: 1px solid #dbdbdb;text-align: center;cursor: pointer;}
.gw_num .num{display: block;float: left;text-align: center;width: 52px;font-style: normal;font-size: 14px;line-height: 26px;border: 0;}
.gw_num em.add{float: right;border-right:0;border-left: 1px solid #dbdbdb;}
|
#!/bin/bash
if [ -z $1 ]
then
exit 0
fi
ip=$1
rules=$2
trunk=$3
access=$4
general_rules='/etc/isida/isida.conf'
get_uplink=`grep 'uplink' $general_rules | cut -d= -f2 | sed -e s/%ip/$ip/`
ism_vlanid=`grep 'ism_vlanid' $general_rules | cut -d= -f2`
port_count=`echo $5 | sed -e s/:
args=''
count=0
enum_pars=`cat $rules | grep -v '#' | grep '\.x\.' | cut -d. -f1 | uniq`
raw_fix='/tmp/'`date +%s%N`'-fix'
not_access=`/usr/local/sbin/<API key>.sh $access $port_count`
not_trunk=`/usr/local/sbin/<API key>.sh $trunk $port_count`
# Traffic control
traf_control_thold=`grep <API key> $rules | cut -d= -f2`
<API key>="config traffic control_trap both"
access_ports="`/usr/local/sbin/interval_to_string.sh $access`"
not_access_ports="`/usr/local/sbin/interval_to_string.sh $not_access`"
<API key>=""
for i in $access_ports
do
<API key>=$<API key>"\nconfig traffic control $i broadcast enable multicast enable unicast disable action drop broadcast_threshold $traf_control_thold multicast_threshold 128 unicast_threshold 131072 countdown 0 time_interval 5"
done
for i in $not_access_ports
do
<API key>=$<API key>"\nconfig traffic control $i broadcast disable multicast disable unicast disable action drop broadcast_threshold $traf_control_thold multicast_threshold 128 unicast_threshold 131072 countdown 0 time_interval 5"
done
# LBD
if [ "`grep lbd_state $rules | cut -d= -f2`" = "enable" ]
then
lbd_state="enable loopdetect"
else
lbd_state="disable loopdetect"
fi
lbd_trap="config loopdetect trap `grep lbd_trap $rules | cut -d= -f2`"
lbd_on=""
for i in $access_ports
do
lbd_on=$lbd_on"\nconfig loopdetect ports $i state enable"
done
lbd_off=""
for i in $not_access_ports
do
lbd_off=$lbd_off"\nconfig loopdetect ports $i state disable"
done
#lbd_off="config loopdetect ports $not_access state disabled"
# Safeguard
sg_state=`grep safeguard_state $rules | cut -d= -f2`
sg_rise=`grep safeguard_rising $rules | cut -d= -f2`
sg_fall=`grep safeguard_falling $rules | cut -d= -f2`
if [ "`grep safeguard_trap $rules | cut -d= -f2`" = "yes" ]
then
sg_trap="enable"
else
sg_trap="disable"
fi
safeguard_string="config safeguard_engine state $sg_state utilization rising $sg_rise falling $sg_fall trap_log $sg_trap mode fuzzy"
# Other
snmp_traps="enable snmp traps\nenable snmp authenticate traps"
dhcp_local_relay="disable dhcp_local_relay"
dhcp_snooping="disable address_binding dhcp_snoop"
impb_acl_mode="disable address_binding acl_mode"
dhcp_screening="config filter dhcp_server ports all state disable\nconfig filter dhcp_server ports $access state enable"
netbios_filter="config filter netbios all state disable\nconfig filter netbios $access state enable"
impb_trap="enable address_binding trap_log"
<API key>="enable <API key>"
arp_aging_time="config arp_aging time `grep arp_aging_time $rules | cut -d= -f2`"
igmp_snooping="enable igmp_snooping"
link_trap="enable snmp linkchange_traps\nconfig snmp linkchange_traps ports 1-28 enable"
# SNTP
sntp_addr1=`grep sntp_primary $rules | cut -d= -f2 | awk -F:: '{print $1}'`
sntp_addr2=`grep sntp_primary $rules | cut -d= -f2 | awk -F:: '{print $2}'`
sntp_string="enable sntp\nconfig sntp primary $sntp_addr1 secondary $sntp_addr2 poll-interval 720\nconfig sntp primary $sntp_addr2 secondary $sntp_addr1"
# IGMP acc <API key>="config igmp <API key> ports $access state enable"
<API key>="config igmp <API key> ports $not_access state disable"
# Limited mcast
range1="config <API key> ports $access add profile_id 1\nconfig <API key> ports $not_access delete profile_id 1"
range2="config <API key> ports $access add profile_id 2\nconfig <API key> ports $not_access delete profile_id 2"
range3="config <API key> ports $access add profile_id 3\nconfig <API key> ports $not_access delete profile_id 3"
range4="config <API key> ports $access add profile_id 4\nconfig <API key> ports $not_access delete profile_id 4"
range5="config <API key> ports $access add profile_id 5\nconfig <API key> ports $not_access delete profile_id 5"
limited_access="config <API key> ports $access access permit"
limited_deny="config <API key> ports $trunk access deny"
# SYSLOG
syslog_ip=`grep 'syslog_host.x.ip' $rules | cut -d= -f2`
#syslog_severity=`grep 'syslog_host.x.severity' $rules | cut -d= -f2`
syslog_facility=`grep 'syslog_host.x.facility' $rules | cut -d= -f2`
syslog_state=`grep 'syslog_host.x.state' $rules | cut -d= -f2`
syslog_del="delete syslog host 2"
syslog_add="create syslog host 2 ipaddress $syslog_ip severity debug facility $syslog_facility state $syslog_state"
syslog_enabled="enable_syslog"
# SNMP
snmp_ip=`grep 'snmp_host.x.ip' $rules | cut -d= -f2`
snmp_community=`grep 'snmp_host.x.community' $rules | cut -d= -f2`
snmp_del="delete snmp host $snmp_ip\ndelete snmp host 192.168.1.120"
snmp_add="create snmp host $snmp_ip v2c $snmp_community"
# RADIUS
radius_ip=`grep 'radius.x.ip' $rules | cut -d= -f2`
radius_key=`grep 'radius.x.key' $rules | cut -d= -f2`
radius_auth=`grep 'radius.x.auth' $rules | cut -d= -f2`
radius_acct=`grep 'radius.x.acct' $rules | cut -d= -f2`
radius_retransmit=`grep 'radius_retransmit' $rules | cut -d= -f2`
radius_timeout=`grep 'radius_timeout' $rules | cut -d= -f2`
radius_del="config radius delete 1"
radius_add="config radius add 1 $radius_ip key $radius_key auth_port $radius_auth acct_port $radius_acct"
radius_params="config radius 1 timeout $radius_timeout retransmit $radius_retransmit"
for i in $@
do
case $i in
"<API key>") echo -e "$<API key>" >> $raw_fix;;
"<API key>") echo -e "$<API key>" >> $raw_fix;;
"<API key>") echo -e "$<API key>" >> $raw_fix;;
"<API key>") echo -e "$<API key>" >> $raw_fix;;
"<API key>") echo -e "$<API key>" >> $raw_fix;;
"lbd_state") echo -e "$lbd_state" >> $raw_fix;;
"lbd_on") echo -e "$lbd_on" >> $raw_fix;;
"lbd_off") echo -e "$lbd_off" >> $raw_fix;;
"lbd_trap") echo -e "$lbd_trap" >> $raw_fix;;
"safeguard_state") echo -e "$safeguard_string" >> $raw_fix;;
"safeguard_trap") echo -e "$safeguard_string" >> $raw_fix;;
"safeguard_rising") echo -e "$safeguard_string" >> $raw_fix;;
"safeguard_falling") echo -e "$safeguard_string" >> $raw_fix;;
"snmp_traps") echo -e "$snmp_traps" >> $raw_fix;;
"dhcp_local_relay") echo -e "$dhcp_local_relay" >> $raw_fix;;
"dhcp_snooping") echo -e "$dhcp_snooping" >> $raw_fix;;
"impb_acl_mode") echo -e "$impb_acl_mode" >> $raw_fix;;
"dhcp_screening") echo -e "$dhcp_screening" >> $raw_fix;;
"netbios_filter") echo -e "$netbios_filter" >> $raw_fix;;
"impb_trap") echo -e "$impb_trap" >> $raw_fix;;
"<API key>") echo -e "$<API key>" >> $raw_fixing;;
"arp_aging_time") echo -e "$arp_aging_time" >> $raw_fix;;
"sntp_state") echo -e "$sntp_string" >> $raw_fix;;
"sntp_primary") echo -e "$sntp_string" >> $raw_fix;;
"sntp_secondary") echo -e "$sntp_string" >> $raw_fix;;
"link_trap") echo -e "$link_trap" >> $raw_fix;;
"mcast_range.iptv1") echo -e "$range1\n$limited_access\n$limited_deny" >> $raw_fix;;
"mcast_range.iptv2") echo -e "$range2\n$limited_access\n$limited_deny" >> $raw_fix;;
"mcast_range.iptv3") echo -e "$range3\n$limited_access\n$limited_deny" >> $raw_fix;;
"mcast_range.iptv4") echo -e "$range4\n$limited_access\n$limited_deny" >> $raw_fix;;
"mcast_range.iptv5") echo -e "$range5\n$limited_access\n$limited_deny" >> $raw_fix;;
"<API key>") echo -e "$<API key>" >> $raw_fix;;
"<API key>") echo -e "$<API key>" >> $raw_fix;;
"syslog_host") echo -e "$syslog_del\n$syslog_add" >> $raw_fix;;
"snmp_host") echo -e "$snmp_del\n$snmp_add" >> $raw_fix;;
"radius") echo -e "$radius_del\n$radius_add\n$radius_params" >> $raw_fix;;
"radius_retransmit") echo -e "$radius_params" >> $raw_fix;;
"radius_timeout") echo -e "$radius_params" >> $raw_fix;;
"igmp_snooping") echo -e "$igmp_snooping" >> $raw_fix;;
"syslog_enabled") echo -e "$syslog_enabled" >> $raw_fix;;
"ism") if [ `/usr/local/sbin/ping_equip.sh $ip` -eq 1 ]
then
ism_prefix='.1.3.6.1.4.1.171.12.64.3.1.1'
ism_name=`snmpget -v2c -c dlread -Ovq $ip $ism_prefix.2.$ism_vlanid | sed -e s/\"
uplink=`$get_uplink`
raw_tagmember=`snmpget -v2c -c dlread -Ovq $ip $ism_prefix.5.$ism_vlanid | sed -e s/\"//g | awk '{print $1 $2 $3 $4}' | xargs -l /usr/local/sbin/portconv.sh`
raw_member=`snmpget -v2c -c dlread -Ovq $ip $ism_prefix.4.$ism_vlanid | sed -e s/\"//g | awk '{print $1 $2 $3 $4}' | xargs -l /usr/local/sbin/portconv.sh`
raw_source=`snmpget -v2c -c dlread -Ovq $ip $ism_prefix.3.$ism_vlanid | sed -e s/\"//g | awk '{print $1 $2 $3 $4}' | xargs -l /usr/local/sbin/portconv.sh`
tagmember=`/usr/local/sbin/string_to_bitmask.sh $raw_tagmember | xargs -l /usr/local/sbin/bitmask_to_interval.sh`
source=`/usr/local/sbin/string_to_bitmask.sh $raw_source | xargs -l /usr/local/sbin/bitmask_to_interval.sh`
echo -e "config igmp_snooping multicast_vlan $ism_name del tag $tagmember" >> $raw_fix
echo -e "config igmp_snooping multicast_vlan $ism_name del source $source" >> $raw_fix
detailed_trunk=`/usr/local/sbin/interval_to_string.sh $trunk`
del_member_raw=''
for i in $detailed_trunk
do
if [ "`echo $raw_member | grep $i`" ]
then
del_member_raw=$del_member_raw" $i"
fi
done
if [ -n "$del_member_raw" ]
then
del_member=`/usr/local/sbin/string_to_bitmask.sh $del_member_raw | xargs -l /usr/local/sbin/bitmask_to_interval.sh`
echo -e "config igmp_snooping multicast_vlan $ism_name del member $del_member" >> $raw_fix
fi
new_source=$uplink
new_tagmember=`echo $detailed_trunk | sed -e s/$uplink// | xargs -l /usr/local/sbin/string_to_bitmask.sh | xargs -l /usr/local/sbin/bitmask_to_interval.sh`
echo -e "config igmp_snooping multicast_vlan $ism_name add source $new_source" >> $raw_fix
echo -e "config igmp_snooping multicast_vlan $ism_name add tag $new_tagmember" >> $raw_fix
fi;;
esac
done
fix_cmd='/tmp/'`date +%s%N`'_fix'
if [ -s $raw_fix ]
then
echo "save" >> $raw_fix
fi
cat $raw_fix | uniq
rm -f $rules $raw_fix
|
/*
Colorbox Core Style:
The following CSS is consistent between example themes and should not be altered.
*/
#colorbox, #cboxOverlay, #cboxWrapper{position:absolute; top:0; left:0; z-index:9999; overflow:hidden;}
#cboxWrapper {max-width:none;}
#cboxOverlay{position:fixed; width:100%; height:100%;}
#cboxMiddleLeft, #cboxBottomLeft{clear:left;}
#cboxContent{position:relative;}
#cboxLoadedContent{overflow:auto; -<API key>: touch;}
#cboxTitle{margin:0;}
#cboxLoadingOverlay, #cboxLoadingGraphic{position:absolute; top:0; left:0; width:100%; height:100%;}
#cboxPrevious, #cboxNext, #cboxClose, #cboxSlideshow{cursor:pointer;}
.cboxPhoto{float:left; margin:auto; border:0; display:block; max-width:none; -<API key>:bicubic;}
.cboxIframe{width:100%; height:100%; display:block; border:0;}
#colorbox, #cboxContent, #cboxLoadedContent{box-sizing:content-box; -moz-box-sizing:content-box; -webkit-box-sizing:content-box;}
/*
User Style:
Change the following styles to modify the appearance of Colorbox. They are
ordered & tabbed in a way that represents the nesting of the generated HTML.
*/
#colorbox{outline:0;}
#cboxTopLeft{width:21px; height:21px; background:url(images/controls.png) no-repeat -101px 0;}
#cboxTopRight{width:21px; height:21px; background:url(images/controls.png) no-repeat -130px 0;}
#cboxBottomLeft{width:21px; height:21px; background:url(images/controls.png) no-repeat -101px -29px;}
#cboxBottomRight{width:21px; height:21px; background:url(images/controls.png) no-repeat -130px -29px;}
#cboxMiddleLeft{width:21px; background:url(images/controls.png) left top repeat-y;}
#cboxMiddleRight{width:21px; background:url(images/controls.png) right top repeat-y;}
#cboxTopCenter{height:21px; background:url(images/border.png) 0 0 repeat-x;}
#cboxBottomCenter{height:21px; background:url(images/border.png) 0 -29px repeat-x;}
#cboxContent{background:#fff; overflow:hidden;}
.cboxIframe{background:#fff;}
#cboxError{padding:50px; border:1px solid #ccc;}
#cboxLoadedContent{margin-bottom:28px;}
#cboxTitle{position:absolute; bottom:4px; left:0; text-align:center; width:100%; color:#949494;}
#cboxCurrent{position:absolute; bottom:4px; left:58px; color:#949494;}
#cboxLoadingOverlay{background:url(images/loading_background.png) no-repeat center center;}
#cboxLoadingGraphic{background:url(images/loading.gif) no-repeat center center;}
/* these elements are buttons, and may need to have additional styles reset to avoid unwanted base styles */
#cboxPrevious, #cboxNext, #cboxSlideshow, #cboxClose {border:0; padding:0; margin:0; overflow:visible; width:auto; background:none; }
/* avoid outlines on :active (mouseclick), but preserve outlines on :focus (tabbed navigating) */
#cboxPrevious:active, #cboxNext:active, #cboxSlideshow:active, #cboxClose:active {outline:0;}
#cboxSlideshow{position:absolute; bottom:4px; right:30px; color:#0092ef;}
#cboxPrevious{position:absolute; bottom:0; left:0; background:url(images/controls.png) no-repeat -75px 0; width:25px; height:25px; text-indent:-9999px;}
#cboxPrevious:hover{background-position:-75px -25px;}
#cboxNext{position:absolute; bottom:0; left:27px; background:url(images/controls.png) no-repeat -50px 0; width:25px; height:25px; text-indent:-9999px;}
#cboxNext:hover{background-position:-50px -25px;}
#cboxClose{position:absolute; bottom:0; right:0; background:url(images/controls.png) no-repeat -25px 0; width:25px; height:25px; text-indent:-9999px;}
#cboxClose:hover{background-position:-25px -25px;}
.cboxIE #cboxTopLeft,
.cboxIE #cboxTopCenter,
.cboxIE #cboxTopRight,
.cboxIE #cboxBottomLeft,
.cboxIE #cboxBottomCenter,
.cboxIE #cboxBottomRight,
.cboxIE #cboxMiddleLeft,
.cboxIE #cboxMiddleRight {
filter: progid:DXImageTransform.Microsoft.gradient(startColorstr=#00FFFFFF,endColorstr=#00FFFFFF);
}
|
<?php
/**
* @file
* Contains \Drupal\Tests\Core\Form\FormBuilderTest.
*/
namespace Drupal\Tests\Core\Form;
use Drupal\Component\Utility\NestedArray;
use Drupal\Core\Access\AccessResult;
use Drupal\Core\Access\<API key>;
use Drupal\Core\DependencyInjection\<API key>;
use Drupal\Core\Form\<API key>;
use Drupal\Core\Form\<API key>;
use Drupal\Core\Form\FormInterface;
use Drupal\Core\Form\FormState;
use Drupal\Core\Form\FormStateInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RequestStack;
use Drupal\Core\Cache\Context\<API key>;
use Symfony\Component\DependencyInjection\ContainerBuilder;
/**
* @coversDefaultClass \Drupal\Core\Form\FormBuilder
* @group Form
*/
class FormBuilderTest extends FormTestBase {
/**
* The dependency injection container.
*
* @var \Symfony\Component\DependencyInjection\ContainerBuilder
*/
protected $container;
/**
* {@inheritdoc}
*/
protected function setUp() {
parent::setUp();
$this->container = new ContainerBuilder();
$<API key> = $this->prophesize(<API key>::class)->reveal();
$this->container->set('<API key>', $<API key>);
\Drupal::setContainer($this->container);
}
/**
* Tests the getFormId() method with a string based form ID.
*
* @expectedException \<API key>
* @<API key> The form argument foo is not a valid form.
*/
public function <API key>() {
$form_arg = 'foo';
$clean_form_state = new FormState();
$form_state = new FormState();
$form_id = $this->formBuilder->getFormId($form_arg, $form_state);
$this->assertSame($form_arg, $form_id);
$this->assertSame($clean_form_state, $form_state);
}
/**
* Tests the getFormId() method with a class name form ID.
*/
public function <API key>() {
$form_arg = 'Drupal\Tests\Core\Form\TestForm';
$form_state = new FormState();
$form_id = $this->formBuilder->getFormId($form_arg, $form_state);
$this->assertSame('test_form', $form_id);
$this->assertSame($form_arg, get_class($form_state->getFormObject()));
}
/**
* Tests the getFormId() method with an injected class name form ID.
*/
public function <API key>() {
$container = $this->getMock('Symfony\Component\DependencyInjection\ContainerInterface');
\Drupal::setContainer($container);
$form_arg = 'Drupal\Tests\Core\Form\TestFormInjected';
$form_state = new FormState();
$form_id = $this->formBuilder->getFormId($form_arg, $form_state);
$this->assertSame('test_form', $form_id);
$this->assertSame($form_arg, get_class($form_state->getFormObject()));
}
/**
* Tests the getFormId() method with a form object.
*/
public function <API key>() {
$expected_form_id = 'my_module_form_id';
$form_arg = $this->getMockForm($expected_form_id);
$form_state = new FormState();
$form_id = $this->formBuilder->getFormId($form_arg, $form_state);
$this->assertSame($expected_form_id, $form_id);
$this->assertSame($form_arg, $form_state->getFormObject());
}
/**
* Tests the getFormId() method with a base form object.
*/
public function <API key>() {
$expected_form_id = 'my_module_form_id';
$base_form_id = 'my_module';
$form_arg = $this->getMock('Drupal\Core\Form\BaseFormIdInterface');
$form_arg->expects($this->once())
->method('getFormId')
->will($this->returnValue($expected_form_id));
$form_arg->expects($this->once())
->method('getBaseFormId')
->will($this->returnValue($base_form_id));
$form_state = new FormState();
$form_id = $this->formBuilder->getFormId($form_arg, $form_state);
$this->assertSame($expected_form_id, $form_id);
$this->assertSame($form_arg, $form_state->getFormObject());
$this->assertSame($base_form_id, $form_state->getBuildInfo()['base_form_id']);
}
/**
* Tests the handling of FormStateInterface::$response.
*
* @dataProvider <API key>
*/
public function <API key>($class, $form_state_key) {
$form_id = 'test_form_id';
$expected_form = $form_id();
$response = $this->getMockBuilder($class)
-><API key>()
->getMock();
$form_arg = $this->getMockForm($form_id, $expected_form);
$form_arg->expects($this->any())
->method('submitForm')
->will($this->returnCallback(function ($form, FormStateInterface $form_state) use ($response, $form_state_key) {
$form_state->setFormState([$form_state_key => $response]);
}));
$form_state = new FormState();
try {
$input['form_id'] = $form_id;
$form_state->setUserInput($input);
$this-><API key>($form_id, $form_arg, $form_state, FALSE);
$this->fail('<API key> was not thrown.');
}
catch (<API key> $e) {
$this->assertSame($response, $e->getResponse());
}
$this->assertSame($response, $form_state->getResponse());
}
/**
* Provides test data for <API key>().
*/
public function <API key>() {
return array(
array('Symfony\Component\HttpFoundation\Response', 'response'),
array('Symfony\Component\HttpFoundation\RedirectResponse', 'redirect'),
);
}
/**
* Tests the handling of a redirect when FormStateInterface::$response exists.
*/
public function <API key>() {
$form_id = 'test_form_id';
$expected_form = $form_id();
// Set up a response that will be used.
$response = $this->getMockBuilder('Symfony\Component\HttpFoundation\Response')
-><API key>()
->getMock();
// Set up a redirect that will not be called.
$redirect = $this->getMockBuilder('Symfony\Component\HttpFoundation\RedirectResponse')
-><API key>()
->getMock();
$form_arg = $this->getMockForm($form_id, $expected_form);
$form_arg->expects($this->any())
->method('submitForm')
->will($this->returnCallback(function ($form, FormStateInterface $form_state) use ($response, $redirect) {
// Set both the response and the redirect.
$form_state->setResponse($response);
$form_state->set('redirect', $redirect);
}));
$form_state = new FormState();
try {
$input['form_id'] = $form_id;
$form_state->setUserInput($input);
$this-><API key>($form_id, $form_arg, $form_state, FALSE);
$this->fail('<API key> was not thrown.');
}
catch (<API key> $e) {
$this->assertSame($response, $e->getResponse());
}
$this->assertSame($response, $form_state->getResponse());
}
/**
* Tests the getForm() method with a string based form ID.
*
* @expectedException \<API key>
* @<API key> The form argument test_form_id is not a valid form.
*/
public function <API key>() {
$form_id = 'test_form_id';
$expected_form = $form_id();
$form = $this->formBuilder->getForm($form_id);
$this->assertFormElement($expected_form, $form, 'test');
$this->assertSame('test-form-id', $form['
}
/**
* Tests the getForm() method with a form object.
*/
public function <API key>() {
$form_id = 'test_form_id';
$expected_form = $form_id();
$form_arg = $this->getMockForm($form_id, $expected_form);
$form = $this->formBuilder->getForm($form_arg);
$this->assertFormElement($expected_form, $form, 'test');
$this->assertArrayHasKey('#id', $form);
}
/**
* Tests the getForm() method with a class name based form ID.
*/
public function <API key>() {
$form_id = '\Drupal\Tests\Core\Form\TestForm';
$object = new TestForm();
$form = array();
$form_state = new FormState();
$expected_form = $object->buildForm($form, $form_state);
$form = $this->formBuilder->getForm($form_id);
$this->assertFormElement($expected_form, $form, 'test');
$this->assertSame('test-form', $form['
}
/**
* Tests the buildForm() method with a string based form ID.
*
* @expectedException \<API key>
* @<API key> The form argument test_form_id is not a valid form.
*/
public function <API key>() {
$form_id = 'test_form_id';
$expected_form = $form_id();
$form = $this->formBuilder->getForm($form_id);
$this->assertFormElement($expected_form, $form, 'test');
$this->assertArrayHasKey('#id', $form);
}
/**
* Tests the buildForm() method with a class name based form ID.
*/
public function <API key>() {
$form_id = '\Drupal\Tests\Core\Form\TestForm';
$object = new TestForm();
$form = array();
$form_state = new FormState();
$expected_form = $object->buildForm($form, $form_state);
$form = $this->formBuilder->buildForm($form_id, $form_state);
$this->assertFormElement($expected_form, $form, 'test');
$this->assertSame('test-form', $form['
}
/**
* Tests the buildForm() method with a form object.
*/
public function <API key>() {
$form_id = 'test_form_id';
$expected_form = $form_id();
$form_arg = $this->getMockForm($form_id, $expected_form);
$form_state = new FormState();
$form = $this->formBuilder->buildForm($form_arg, $form_state);
$this->assertFormElement($expected_form, $form, 'test');
$this->assertSame($form_id, $form_state->getBuildInfo()['form_id']);
$this->assertArrayHasKey('#id', $form);
}
/**
* Tests the rebuildForm() method for a POST submission.
*/
public function testRebuildForm() {
$form_id = 'test_form_id';
$expected_form = $form_id();
// The form will be built four times.
$form_arg = $this->getMock('Drupal\Core\Form\FormInterface');
$form_arg->expects($this->exactly(2))
->method('getFormId')
->will($this->returnValue($form_id));
$form_arg->expects($this->exactly(4))
->method('buildForm')
->will($this->returnValue($expected_form));
// Do an initial build of the form and track the build ID.
$form_state = new FormState();
$form = $this->formBuilder->buildForm($form_arg, $form_state);
$original_build_id = $form['#build_id'];
$this->request->setMethod('POST');
$form_state->setRequestMethod('POST');
// Rebuild the form, and assert that the build ID has not changed.
$form_state->setRebuild();
$input['form_id'] = $form_id;
$form_state->setUserInput($input);
$form_state->addRebuildInfo('copy', ['#build_id' => TRUE]);
$this->formBuilder->processForm($form_id, $form, $form_state);
$this->assertSame($original_build_id, $form['#build_id']);
$this->assertTrue($form_state->isCached());
// Rebuild the form again, and assert that there is a new build ID.
$form_state->setRebuildInfo([]);
$form = $this->formBuilder->buildForm($form_arg, $form_state);
$this->assertNotSame($original_build_id, $form['#build_id']);
$this->assertTrue($form_state->isCached());
}
/**
* Tests the rebuildForm() method for a GET submission.
*/
public function <API key>() {
$form_id = 'test_form_id';
$expected_form = $form_id();
// The form will be built four times.
$form_arg = $this->getMock('Drupal\Core\Form\FormInterface');
$form_arg->expects($this->exactly(2))
->method('getFormId')
->will($this->returnValue($form_id));
$form_arg->expects($this->exactly(4))
->method('buildForm')
->will($this->returnValue($expected_form));
// Do an initial build of the form and track the build ID.
$form_state = new FormState();
$form_state->setMethod('GET');
$form = $this->formBuilder->buildForm($form_arg, $form_state);
$original_build_id = $form['#build_id'];
// Rebuild the form, and assert that the build ID has not changed.
$form_state->setRebuild();
$input['form_id'] = $form_id;
$form_state->setUserInput($input);
$form_state->addRebuildInfo('copy', ['#build_id' => TRUE]);
$this->formBuilder->processForm($form_id, $form, $form_state);
$this->assertSame($original_build_id, $form['#build_id']);
$this->assertFalse($form_state->isCached());
// Rebuild the form again, and assert that there is a new build ID.
$form_state->setRebuildInfo([]);
$form = $this->formBuilder->buildForm($form_arg, $form_state);
$this->assertNotSame($original_build_id, $form['#build_id']);
$this->assertFalse($form_state->isCached());
}
/**
* Tests the getCache() method.
*/
public function testGetCache() {
$form_id = 'test_form_id';
$expected_form = $form_id();
$expected_form['#token'] = FALSE;
// FormBuilder::buildForm() will be called twice, but the form object will
// only be called once due to caching.
$form_arg = $this->getMock('Drupal\Core\Form\FormInterface');
$form_arg->expects($this->exactly(2))
->method('getFormId')
->will($this->returnValue($form_id));
$form_arg->expects($this->once())
->method('buildForm')
->will($this->returnValue($expected_form));
// Do an initial build of the form and track the build ID.
$form_state = (new FormState())
->addBuildInfo('files', [['module' => 'node', 'type' => 'pages.inc']])
->setRequestMethod('POST')
->setCached();
$form = $this->formBuilder->buildForm($form_arg, $form_state);
$cached_form = $form;
$cached_form['#cache_token'] = 'csrf_token';
// The form cache, form_state cache, and CSRF token validation will only be
// called on the cached form.
$this->formCache->expects($this->once())
->method('getCache')
->willReturn($form);
// The final form build will not trigger any actual form building, but will
// use the form cache.
$form_state->setExecuted();
$input['form_id'] = $form_id;
$input['form_build_id'] = $form['#build_id'];
$form_state->setUserInput($input);
$this->formBuilder->buildForm($form_arg, $form_state);
$this->assertEmpty($form_state->getErrors());
}
/**
* Tests that HTML IDs are unique when rebuilding a form with errors.
*/
public function testUniqueHtmlId() {
$form_id = 'test_form_id';
$expected_form = $form_id();
$expected_form['test']['#required'] = TRUE;
// Mock a form object that will be built two times.
$form_arg = $this->getMock('Drupal\Core\Form\FormInterface');
$form_arg->expects($this->exactly(2))
->method('getFormId')
->will($this->returnValue($form_id));
$form_arg->expects($this->exactly(2))
->method('buildForm')
->will($this->returnValue($expected_form));
$form_state = new FormState();
$form = $this-><API key>($form_id, $form_arg, $form_state);
$this->assertSame('test-form-id', $form['
$form_state = new FormState();
$form = $this-><API key>($form_id, $form_arg, $form_state);
$this->assertSame('test-form-id--2', $form['
}
/**
* Tests that a cached form is deleted after submit.
*/
public function <API key>() {
$form_id = 'test_form_id';
$form_build_id = $this->randomMachineName();
$expected_form = $form_id();
$expected_form['#build_id'] = $form_build_id;
$form_arg = $this->getMockForm($form_id, $expected_form);
$form_arg->expects($this->once())
->method('submitForm')
->willReturnCallback(function (array &$form, FormStateInterface $form_state) {
// Mimic EntityForm by cleaning the $form_state upon submit.
$form_state->cleanValues();
});
$this->formCache->expects($this->once())
->method('deleteCache')
->with($form_build_id);
$form_state = new FormState();
$form_state->setRequestMethod('POST');
$form_state->setCached();
$this-><API key>($form_id, $form_arg, $form_state);
}
/**
* Tests that an uncached form does not trigger cache set or delete.
*/
public function <API key>() {
$form_id = 'test_form_id';
$form_build_id = $this->randomMachineName();
$expected_form = $form_id();
$expected_form['#build_id'] = $form_build_id;
$form_arg = $this->getMockForm($form_id, $expected_form);
$this->formCache->expects($this->never())
->method('deleteCache');
$form_state = new FormState();
$this-><API key>($form_id, $form_arg, $form_state);
}
/**
* @covers ::buildForm
*
* @expectedException \Drupal\Core\Form\Exception\<API key>
*/
public function <API key>() {
$request = new Request([<API key>::AJAX_FORM_REQUEST => TRUE]);
$request_stack = new RequestStack();
$request_stack->push($request);
$this->formBuilder = $this->getMockBuilder('\Drupal\Core\Form\FormBuilder')
->setConstructorArgs([$this->formValidator, $this->formSubmitter, $this->formCache, $this->moduleHandler, $this->eventDispatcher, $request_stack, $this->classResolver, $this->elementInfo, $this->themeManager, $this->csrfToken])
->setMethods(['<API key>'])
->getMock();
$this->formBuilder->expects($this->once())
->method('<API key>')
->willReturn(33554432);
$form_arg = $this->getMockForm('test_form_id');
$form_state = new FormState();
$this->formBuilder->buildForm($form_arg, $form_state);
}
/**
* @covers ::buildForm
*
* @dataProvider <API key>
*/
public function <API key>($element, $access_checks) {
$form_arg = new <API key>();
$form_arg->setForm($element);
$form_state = new FormState();
$form = $this->formBuilder->buildForm($form_arg, $form_state);
$<API key> = [];
$<API key> = [];
// Ensure that the expected access checks are set.
foreach ($access_checks as $access_check) {
$parents = $access_check[0];
$parents[] = '#access';
$actual_access = NestedArray::getValue($form, $parents);
$<API key>[] = [$parents, $actual_access];
$<API key>[] = [$parents, $access_check[1]];
}
$this->assertEquals($<API key>, $<API key>);
}
/**
* Data provider for <API key>.
*
* @return array
*/
public function <API key>() {
$data = [];
$element = [
'child0' => [
'#type' => 'checkbox',
],
'child1' => [
'#type' => 'checkbox',
],
'child2' => [
'#type' => 'fieldset',
'child2.0' => [
'#type' => 'checkbox',
],
'child2.1' => [
'#type' => 'checkbox',
],
'child2.2' => [
'#type' => 'checkbox',
],
],
];
// Sets access FALSE on the root level, this should be inherited completely.
$clone = $element;
$clone['#access'] = FALSE;
$expected_access = [];
$expected_access[] = [[], FALSE];
$expected_access[] = [['child0'], FALSE];
$expected_access[] = [['child1'], FALSE];
$expected_access[] = [['child2'], FALSE];
$expected_access[] = [['child2', 'child2.0'], FALSE];
$expected_access[] = [['child2', 'child2.1'], FALSE];
$expected_access[] = [['child2', 'child2.2'], FALSE];
$data['access-false-root'] = [$clone, $expected_access];
$clone = $element;
$access_result = AccessResult::forbidden();
$clone['#access'] = $access_result;
$expected_access = [];
$expected_access[] = [[], $access_result];
$expected_access[] = [['child0'], $access_result];
$expected_access[] = [['child1'], $access_result];
$expected_access[] = [['child2'], $access_result];
$expected_access[] = [['child2', 'child2.0'], $access_result];
$expected_access[] = [['child2', 'child2.1'], $access_result];
$expected_access[] = [['child2', 'child2.2'], $access_result];
$data['<API key>'] = [$clone, $expected_access];
// Allow access on the most outer level but set FALSE otherwise.
$clone = $element;
$clone['#access'] = TRUE;
$clone['child0']['#access'] = FALSE;
$expected_access = [];
$expected_access[] = [[], TRUE];
$expected_access[] = [['child0'], FALSE];
$expected_access[] = [['child1'], NULL];
$expected_access[] = [['child2'], NULL];
$expected_access[] = [['child2', 'child2.0'], NULL];
$expected_access[] = [['child2', 'child2.1'], NULL];
$expected_access[] = [['child2', 'child2.2'], NULL];
$data['access-true-root'] = [$clone, $expected_access];
// Allow access on the most outer level but forbid otherwise.
$clone = $element;
$<API key> = AccessResult::allowed();
$clone['#access'] = $<API key>;
$<API key> = AccessResult::forbidden();
$clone['child0']['#access'] = $<API key>;
$expected_access = [];
$expected_access[] = [[], $<API key>];
$expected_access[] = [['child0'], $<API key>];
$expected_access[] = [['child1'], NULL];
$expected_access[] = [['child2'], NULL];
$expected_access[] = [['child2', 'child2.0'], NULL];
$expected_access[] = [['child2', 'child2.1'], NULL];
$expected_access[] = [['child2', 'child2.2'], NULL];
$data['access-allowed-root'] = [$clone, $expected_access];
// Allow access on the most outer level, deny access on a parent, and allow
// on a child. The denying should be inherited.
$clone = $element;
$clone['#access'] = TRUE;
$clone['child2']['#access'] = FALSE;
$clone['child2.0']['#access'] = TRUE;
$clone['child2.1']['#access'] = TRUE;
$clone['child2.2']['#access'] = TRUE;
$expected_access = [];
$expected_access[] = [[], TRUE];
$expected_access[] = [['child0'], NULL];
$expected_access[] = [['child1'], NULL];
$expected_access[] = [['child2'], FALSE];
$expected_access[] = [['child2', 'child2.0'], FALSE];
$expected_access[] = [['child2', 'child2.1'], FALSE];
$expected_access[] = [['child2', 'child2.2'], FALSE];
$data['<API key>'] = [$clone, $expected_access];
$clone = $element;
$clone['#access'] = $<API key>;
$clone['child2']['#access'] = $<API key>;
$clone['child2.0']['#access'] = $<API key>;
$clone['child2.1']['#access'] = $<API key>;
$clone['child2.2']['#access'] = $<API key>;
$expected_access = [];
$expected_access[] = [[], $<API key>];
$expected_access[] = [['child0'], NULL];
$expected_access[] = [['child1'], NULL];
$expected_access[] = [['child2'], $<API key>];
$expected_access[] = [['child2', 'child2.0'], $<API key>];
$expected_access[] = [['child2', 'child2.1'], $<API key>];
$expected_access[] = [['child2', 'child2.2'], $<API key>];
$data['<API key>'] = [$clone, $expected_access];
return $data;
}
}
class TestForm implements FormInterface {
public function getFormId() {
return 'test_form';
}
public function buildForm(array $form, FormStateInterface $form_state) {
return test_form_id();
}
public function validateForm(array &$form, FormStateInterface $form_state) { }
public function submitForm(array &$form, FormStateInterface $form_state) { }
}
class TestFormInjected extends TestForm implements <API key> {
public static function create(ContainerInterface $container) {
return new static();
}
}
class <API key> extends TestForm {
/**
* @var array
*/
protected $form;
public function setForm($form) {
$this->form = $form;
}
public function buildForm(array $form, FormStateInterface $form_state) {
return $this->form;
}
}
|
<?php
/**
* DmUserGroupTable
*
* This class has been auto-generated by the Doctrine ORM Framework
*/
class DmUserGroupTable extends <API key>
{
/**
* Returns an instance of this class.
*
* @return DmUserGroupTable The table object
*/
public static function getInstance()
{
return Doctrine_Core::getTable('DmUserGroup');
}
}
|
package database.parse.util;
import almonds.Parse;
import almonds.ParseObject;
import database.parse.tables.ParsePhenomena;
import database.parse.tables.ParseSensor;
import java.net.URI;
/**
*
* @author jried31
*/
public class DBGlobals {
static public String TABLE_PHENOMENA="tester";
static public String TABLE_SENSOR="Sensor";
public static String URL_GOOGLE_SEARCH="http://suggestqueries.google.com/complete/search?client=firefox&hl=en&q=WORD";
public static void InitializeParse(){
//App Ids for Connecting to the Parse DB
Parse.initialize("<API key>", //Application ID
"<API key>"); //Rest API Key
}
}
|
/*
* The Mass Storage Function acts as a USB Mass Storage device,
* appearing to the host as a disk drive or as a CD-ROM drive. In
* addition to providing an example of a genuinely useful composite
* function for a USB device, it also illustrates a technique of
* double-buffering for increased throughput.
*
* For more information about MSF and in particular its module
* parameters and sysfs interface read the
* <Documentation/usb/mass-storage.txt> file.
*/
/*
* Driver Design
*
* The MSF is fairly straightforward. There is a main kernel
* thread that handles most of the work. Interrupt routines field
* callbacks from the controller driver: bulk- and interrupt-request
* completion notifications, endpoint-0 events, and disconnect events.
* Completion events are passed to the main thread by wakeup calls. Many
* ep0 requests are handled at interrupt time, but SetInterface,
* SetConfiguration, and device reset requests are forwarded to the
* thread in the form of "exceptions" using SIGUSR1 signals (since they
* should interrupt any ongoing file I/O operations).
*
* The thread's main routine implements the standard command/data/status
* parts of a SCSI interaction. It and its subroutines are full of tests
* for pending signals/exceptions -- all this polling is necessary since
* the kernel has no setjmp/longjmp equivalents. (Maybe this is an
* indication that the driver really wants to be running in userspace.)
* An important point is that so long as the thread is alive it keeps an
* open reference to the backing file. This will prevent unmounting
* the backing file's underlying filesystem and could cause problems
* during system shutdown, for example. To prevent such problems, the
* thread catches INT, TERM, and KILL signals and converts them into
* an EXIT exception.
*
* In normal operation the main thread is started during the gadget's
* fsg_bind() callback and stopped during fsg_unbind(). But it can
* also exit when it receives a signal, and there's no point leaving
* the gadget running when the thread is dead. As of this moment, MSF
* provides no way to deregister the gadget when thread dies -- maybe
* a callback functions is needed.
*
* To provide maximum throughput, the driver uses a circular pipeline of
* buffer heads (struct fsg_buffhd). In principle the pipeline can be
* arbitrarily long; in practice the benefits don't justify having more
* than 2 stages (i.e., double buffering). But it helps to think of the
* pipeline as being a long one. Each buffer head contains a bulk-in and
* a bulk-out request pointer (since the buffer can be used for both
* output and input -- directions always are given from the host's
* point of view) as well as a pointer to the buffer and various state
* variables.
*
* Use of the pipeline follows a simple protocol. There is a variable
* (fsg->next_buffhd_to_fill) that points to the next buffer head to use.
* At any time that buffer head may still be in use from an earlier
* request, so each buffer head has a state variable indicating whether
* it is EMPTY, FULL, or BUSY. Typical use involves waiting for the
* buffer head to be EMPTY, filling the buffer either by file I/O or by
* USB I/O (during which the buffer head is BUSY), and marking the buffer
* head FULL when the I/O is complete. Then the buffer will be emptied
* (again possibly by USB I/O, during which it is marked BUSY) and
* finally marked EMPTY again (possibly by a completion routine).
*
* A module parameter tells the driver to avoid stalling the bulk
* endpoints wherever the transport specification allows. This is
* necessary for some UDCs like the SuperH, which cannot reliably clear a
* halt on a bulk endpoint. However, under certain circumstances the
* Bulk-only specification requires a stall. In such cases the driver
* will halt the endpoint and set a flag indicating that it should clear
* the halt in software during the next device reset. Hopefully this
* will permit everything to work correctly. Furthermore, although the
* specification allows the bulk-out endpoint to halt when the host sends
* too much data, implementing this would cause an unavoidable race.
* The driver will always use the "no-stall" approach for OUT transfers.
*
* One subtle point concerns sending status-stage responses for ep0
* requests. Some of these requests, such as device reset, can involve
* interrupting an ongoing file I/O operation, which might take an
* arbitrarily long time. During that delay the host might give up on
* the original ep0 request and issue a new one. When that happens the
* driver should not notify the host about completion of the original
* request, as the host will no longer be waiting for it. So the driver
* assigns to each ep0 request a unique tag, and it keeps track of the
* tag value of the request associated with a long-running exception
* (device-reset, interface-change, or <API key>). When the
* exception handler is finished, the status-stage response is submitted
* only if the current ep0 request tag is equal to the exception request
* tag. Thus only the most recently received ep0 request will get a
* status-stage response.
*
* Warning: This driver source file is too long. It ought to be split up
* into a header file plus about 3 separate .c files, to handle the details
* of the Gadget, USB Mass Storage, and SCSI protocols.
*/
/* #define VERBOSE_DEBUG */
/* #define DUMP_MSGS */
#include <linux/blkdev.h>
#include <linux/completion.h>
#include <linux/dcache.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/fcntl.h>
#include <linux/file.h>
#include <linux/fs.h>
#include <linux/kref.h>
#include <linux/kthread.h>
#include <linux/limits.h>
#include <linux/rwsem.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/string.h>
#include <linux/freezer.h>
#include <linux/module.h>
#include <linux/usb/ch9.h>
#include <linux/usb/gadget.h>
#include <linux/usb/composite.h>
#include "gadget_chips.h"
#include "configfs.h"
#define FSG_DRIVER_DESC "Mass Storage Function"
#define FSG_DRIVER_VERSION "2009/09/11"
static const char <API key>[] = "Mass Storage";
#include "storage_common.h"
#include "f_mass_storage.h"
/* Static strings, in UTF-8 (for simplicity we use only ASCII characters) */
static struct usb_string fsg_strings[] = {
{<API key>, <API key>},
{}
};
static struct usb_gadget_strings fsg_stringtab = {
.language = 0x0409, /* en-us */
.strings = fsg_strings,
};
static struct usb_gadget_strings *fsg_strings_array[] = {
&fsg_stringtab,
NULL,
};
/*
* If USB mass storage vfs operation is stuck for more than 10 sec
* host will initiate the reset. Configure the timer with 9 sec to print
* the error message before host is intiating the resume on it.
*/
#define <API key> 9000
static int <API key> = <API key>;
module_param(<API key>, int, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(<API key>, "Set period for MSC VFS timer");
static int <API key>;
static int must_report_residue;
static int csw_sent;
struct fsg_dev;
struct fsg_common;
/* Data shared by all the FSG instances. */
struct fsg_common {
struct usb_gadget *gadget;
struct usb_composite_dev *cdev;
struct fsg_dev *fsg, *new_fsg;
wait_queue_head_t fsg_wait;
/* filesem protects: backing files in use */
struct rw_semaphore filesem;
/* lock protects: state, all the req_busy's */
spinlock_t lock;
struct usb_ep *ep0; /* Copy of gadget->ep0 */
struct usb_request *ep0req; /* Copy of cdev->req */
unsigned int ep0_req_tag;
struct fsg_buffhd *next_buffhd_to_fill;
struct fsg_buffhd *<API key>;
struct fsg_buffhd *buffhds;
unsigned int fsg_num_buffers;
int cmnd_size;
u8 cmnd[MAX_COMMAND_SIZE];
unsigned int nluns;
unsigned int lun;
struct fsg_lun **luns;
struct fsg_lun *curlun;
unsigned int bulk_out_maxpacket;
enum fsg_state state; /* For exception handling */
unsigned int exception_req_tag;
enum data_direction data_dir;
u32 data_size;
u32 data_size_from_cmnd;
u32 tag;
u32 residue;
u32 usb_amount_left;
unsigned int can_stall:1;
unsigned int <API key>:1;
unsigned int phase_error:1;
unsigned int <API key>:1;
unsigned int bad_lun_okay:1;
unsigned int running:1;
unsigned int sysfs:1;
int <API key>;
struct completion thread_notifier;
struct task_struct *thread_task;
/* Callback functions. */
const struct fsg_operations *ops;
/* Gadget's private data. */
void *private_data;
char inquiry_string[INQUIRY_MAX_LEN];
/* LUN name for sysfs purpose */
char name[FSG_MAX_LUNS][LUN_NAME_LEN];
struct kref ref;
struct timer_list vfs_timer;
};
struct fsg_dev {
struct usb_function function;
struct usb_gadget *gadget; /* Copy of cdev->gadget */
struct fsg_common *common;
u16 interface_number;
unsigned int bulk_in_enabled:1;
unsigned int bulk_out_enabled:1;
unsigned long atomic_bitflags;
#define IGNORE_BULK_OUT 0
struct usb_ep *bulk_in;
struct usb_ep *bulk_out;
};
static void <API key>(unsigned long data)
{
struct fsg_common *common = (struct fsg_common *) data;
switch (common->data_dir) {
case DATA_DIR_FROM_HOST:
dev_err(&common->curlun->dev,
"usb mass storage stuck in vfs_write\n");
break;
case DATA_DIR_TO_HOST:
dev_err(&common->curlun->dev,
"usb mass storage stuck in vfs_read\n");
break;
default:
dev_err(&common->curlun->dev,
"usb mass storage stuck in vfs_sync\n");
break;
}
}
static inline int __fsg_is_set(struct fsg_common *common,
const char *func, unsigned line)
{
if (common->fsg)
return 1;
ERROR(common, "common->fsg is NULL in %s at %u\n", func, line);
WARN_ON(1);
return 0;
}
#define fsg_is_set(common) likely(__fsg_is_set(common, __func__, __LINE__))
static inline struct fsg_dev *fsg_from_func(struct usb_function *f)
{
return container_of(f, struct fsg_dev, function);
}
typedef void (*fsg_routine_t)(struct fsg_dev *);
static int send_status(struct fsg_common *common);
static int <API key>(struct fsg_common *common)
{
return common->state > FSG_STATE_IDLE;
}
/* Make bulk-out requests be divisible by the maxpacket size */
static void <API key>(struct fsg_common *common,
struct fsg_buffhd *bh, unsigned int length)
{
unsigned int rem;
bh-><API key> = length;
rem = length % common->bulk_out_maxpacket;
if (rem > 0)
length += common->bulk_out_maxpacket - rem;
bh->outreq->length = length;
}
static int fsg_set_halt(struct fsg_dev *fsg, struct usb_ep *ep)
{
const char *name;
if (ep == fsg->bulk_in)
name = "bulk-in";
else if (ep == fsg->bulk_out)
name = "bulk-out";
else
name = ep->name;
DBG(fsg, "%s set halt\n", name);
return usb_ep_set_halt(ep);
}
/* These routines may be called in process context or in_irq */
/* Caller must hold fsg->lock */
static void wakeup_thread(struct fsg_common *common)
{
smp_wmb(); /* ensure the write of bh->state is complete */
/* Tell the main thread that something has happened */
common-><API key> = 1;
if (common->thread_task)
wake_up_process(common->thread_task);
}
static void raise_exception(struct fsg_common *common, enum fsg_state new_state)
{
unsigned long flags;
/*
* Do nothing if a higher-priority exception is already in progress.
* If a lower-or-equal priority exception is in progress, preempt it
* and notify the main thread by sending it a signal.
*/
spin_lock_irqsave(&common->lock, flags);
if (common->state <= new_state) {
common->exception_req_tag = common->ep0_req_tag;
common->state = new_state;
if (common->thread_task)
send_sig_info(SIGUSR1, SEND_SIG_FORCED,
common->thread_task);
}
<API key>(&common->lock, flags);
}
static int ep0_queue(struct fsg_common *common)
{
int rc;
rc = usb_ep_queue(common->ep0, common->ep0req, GFP_ATOMIC);
common->ep0->driver_data = common;
if (rc != 0 && rc != -ESHUTDOWN) {
/* We can't do much more than wait for a reset */
WARNING(common, "error in submission: %s
common->ep0->name, rc);
}
return rc;
}
/* Completion handlers. These always run in_irq. */
static void bulk_in_complete(struct usb_ep *ep, struct usb_request *req)
{
struct fsg_common *common = ep->driver_data;
struct fsg_buffhd *bh = req->context;
if (req->status || req->actual != req->length)
pr_debug("%s --> %d, %u/%u\n", __func__,
req->status, req->actual, req->length);
if (req->status == -ECONNRESET) /* Request was cancelled */
usb_ep_fifo_flush(ep);
/* Hold the lock while we update the request and buffer states */
smp_wmb();
/*
* Disconnect and completion might race each other and driver data
* is set to NULL during ep disable. So, add a check if that is case.
*/
if (!common) {
bh->inreq_busy = 0;
bh->state = BUF_STATE_EMPTY;
return;
}
spin_lock(&common->lock);
bh->inreq_busy = 0;
bh->state = BUF_STATE_EMPTY;
wakeup_thread(common);
spin_unlock(&common->lock);
}
static void bulk_out_complete(struct usb_ep *ep, struct usb_request *req)
{
struct fsg_common *common = ep->driver_data;
struct fsg_buffhd *bh = req->context;
dump_msg(common, "bulk-out", req->buf, req->actual);
if (req->status || req->actual != bh-><API key>)
DBG(common, "%s --> %d, %u/%u\n", __func__,
req->status, req->actual, bh-><API key>);
if (req->status == -ECONNRESET) /* Request was cancelled */
usb_ep_fifo_flush(ep);
/* Hold the lock while we update the request and buffer states */
smp_wmb();
spin_lock(&common->lock);
bh->outreq_busy = 0;
bh->state = BUF_STATE_FULL;
wakeup_thread(common);
spin_unlock(&common->lock);
}
static int fsg_setup(struct usb_function *f,
const struct usb_ctrlrequest *ctrl)
{
struct fsg_dev *fsg = fsg_from_func(f);
struct usb_request *req = fsg->common->ep0req;
u16 w_index = le16_to_cpu(ctrl->wIndex);
u16 w_value = le16_to_cpu(ctrl->wValue);
u16 w_length = le16_to_cpu(ctrl->wLength);
if (!fsg_is_set(fsg->common))
return -EOPNOTSUPP;
++fsg->common->ep0_req_tag; /* Record arrival of a new request */
req->context = NULL;
req->length = 0;
dump_msg(fsg, "ep0-setup", (u8 *) ctrl, sizeof(*ctrl));
switch (ctrl->bRequest) {
case <API key>:
if (ctrl->bRequestType !=
(USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE))
break;
if (w_index != fsg->interface_number || w_value != 0 ||
w_length != 0)
return -EDOM;
/*
* Raise an exception to stop the current operation
* and reinitialize our state.
*/
DBG(fsg, "bulk reset request\n");
raise_exception(fsg->common, FSG_STATE_RESET);
return <API key>;
case US_BULK_GET_MAX_LUN:
if (ctrl->bRequestType !=
(USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE))
break;
if (w_index != fsg->interface_number || w_value != 0 ||
w_length != 1)
return -EDOM;
VDBG(fsg, "get max LUN\n");
*(u8 *)req->buf = fsg->common->nluns - 1;
/* Respond with data/status */
req->length = min((u16)1, w_length);
return ep0_queue(fsg->common);
}
VDBG(fsg,
"unknown class-specific control req %02x.%02x v%04x i%04x l%u\n",
ctrl->bRequestType, ctrl->bRequest,
le16_to_cpu(ctrl->wValue), w_index, w_length);
return -EOPNOTSUPP;
}
/* All the following routines run in process context */
/* Use this for bulk or interrupt transfers, not ep0 */
static void start_transfer(struct fsg_dev *fsg, struct usb_ep *ep,
struct usb_request *req, int *pbusy,
enum fsg_buffer_state *state)
{
int rc;
if (ep == fsg->bulk_in)
dump_msg(fsg, "bulk-in", req->buf, req->length);
spin_lock_irq(&fsg->common->lock);
*pbusy = 1;
*state = BUF_STATE_BUSY;
spin_unlock_irq(&fsg->common->lock);
rc = usb_ep_queue(ep, req, GFP_KERNEL);
if (rc == 0)
return; /* All good, we're done */
*pbusy = 0;
*state = BUF_STATE_EMPTY;
/* We can't do much more than wait for a reset */
/*
* Note: currently the net2280 driver fails zero-length
* submissions if DMA is enabled.
*/
if (rc != -ESHUTDOWN && !(rc == -EOPNOTSUPP && req->length == 0))
WARNING(fsg, "error in submission: %s --> %d\n", ep->name, rc);
}
static bool start_in_transfer(struct fsg_common *common, struct fsg_buffhd *bh)
{
if (!fsg_is_set(common))
return false;
start_transfer(common->fsg, common->fsg->bulk_in,
bh->inreq, &bh->inreq_busy, &bh->state);
return true;
}
static bool start_out_transfer(struct fsg_common *common, struct fsg_buffhd *bh)
{
if (!fsg_is_set(common))
return false;
start_transfer(common->fsg, common->fsg->bulk_out,
bh->outreq, &bh->outreq_busy, &bh->state);
return true;
}
static int sleep_thread(struct fsg_common *common, bool can_freeze)
{
int rc = 0;
/* Wait until a signal arrives or we are woken up */
for (;;) {
if (can_freeze)
try_to_freeze();
set_current_state(TASK_INTERRUPTIBLE);
if (signal_pending(current)) {
rc = -EINTR;
break;
}
spin_lock_irq(&common->lock);
if (common-><API key>) {
spin_unlock_irq(&common->lock);
break;
}
spin_unlock_irq(&common->lock);
schedule();
}
__set_current_state(TASK_RUNNING);
spin_lock_irq(&common->lock);
common-><API key> = 0;
spin_unlock_irq(&common->lock);
smp_rmb(); /* ensure the latest bh->state is visible */
return rc;
}
static int do_read(struct fsg_common *common)
{
struct fsg_lun *curlun = common->curlun;
u32 lba;
struct fsg_buffhd *bh;
int rc;
u32 amount_left;
loff_t file_offset, file_offset_tmp;
unsigned int amount;
ssize_t nread;
ktime_t start, diff;
/*
* Get the starting Logical Block Address and check that it's
* not too big.
*/
if (common->cmnd[0] == READ_6)
lba = get_unaligned_be24(&common->cmnd[1]);
else {
lba = get_unaligned_be32(&common->cmnd[2]);
/*
* We allow DPO (Disable Page Out = don't save data in the
* cache) and FUA (Force Unit Access = don't read from the
* cache), but we don't implement them.
*/
if ((common->cmnd[1] & ~0x18) != 0) {
curlun->sense_data = <API key>;
return -EINVAL;
}
}
if (lba >= curlun->num_sectors) {
curlun->sense_data = <API key>;
return -EINVAL;
}
file_offset = ((loff_t) lba) << curlun->blkbits;
/* Carry out the file reads */
amount_left = common->data_size_from_cmnd;
if (unlikely(amount_left == 0))
return -EIO; /* No default reply */
for (;;) {
/*
* Figure out how much we need to read:
* Try to read the remaining amount.
* But don't read more than the buffer size.
* And don't try to read past the end of the file.
*/
amount = min(amount_left, FSG_BUFLEN);
amount = min((loff_t)amount,
curlun->file_length - file_offset);
/* Wait for the next buffer to become available */
spin_lock_irq(&common->lock);
bh = common->next_buffhd_to_fill;
while (bh->state != BUF_STATE_EMPTY) {
spin_unlock_irq(&common->lock);
rc = sleep_thread(common, false);
if (rc)
return rc;
spin_lock_irq(&common->lock);
}
spin_unlock_irq(&common->lock);
/*
* If we were asked to read past the end of file,
* end with an empty buffer.
*/
if (amount == 0) {
curlun->sense_data =
<API key>;
curlun->sense_data_info =
file_offset >> curlun->blkbits;
curlun->info_valid = 1;
spin_lock_irq(&common->lock);
bh->inreq->length = 0;
bh->state = BUF_STATE_FULL;
spin_unlock_irq(&common->lock);
break;
}
/* Perform the read */
file_offset_tmp = file_offset;
start = ktime_get();
mod_timer(&common->vfs_timer, jiffies +
msecs_to_jiffies(<API key>));
nread = vfs_read(curlun->filp,
(char __user *)bh->buf,
amount, &file_offset_tmp);
del_timer_sync(&common->vfs_timer);
VLDBG(curlun, "file read %u @ %llu -> %d\n", amount,
(unsigned long long)file_offset, (int)nread);
diff = ktime_sub(ktime_get(), start);
curlun->perf.rbytes += nread;
curlun->perf.rtime = ktime_add(curlun->perf.rtime, diff);
if (signal_pending(current))
return -EINTR;
if (nread < 0) {
LDBG(curlun, "error in file read: %d\n", (int)nread);
nread = 0;
} else if (nread < amount) {
LDBG(curlun, "partial file read: %d/%u\n",
(int)nread, amount);
nread = round_down(nread, curlun->blksize);
}
file_offset += nread;
amount_left -= nread;
common->residue -= nread;
/*
* Except at the end of the transfer, nread will be
* equal to the buffer size, which is divisible by the
* bulk-in maxpacket size.
*/
spin_lock_irq(&common->lock);
bh->inreq->length = nread;
bh->state = BUF_STATE_FULL;
spin_unlock_irq(&common->lock);
/* If an error occurred, report it and its position */
if (nread < amount) {
curlun->sense_data = <API key>;
curlun->sense_data_info =
file_offset >> curlun->blkbits;
curlun->info_valid = 1;
break;
}
if (amount_left == 0)
break; /* No more left to read */
/* Send this buffer and go read some more */
bh->inreq->zero = 0;
if (!start_in_transfer(common, bh))
/* Don't know what to do if common->fsg is NULL */
return -EIO;
common->next_buffhd_to_fill = bh->next;
}
return -EIO; /* No default reply */
}
static int do_write(struct fsg_common *common)
{
struct fsg_lun *curlun = common->curlun;
u32 lba;
struct fsg_buffhd *bh;
int get_some_more;
u32 amount_left_to_req, <API key>;
loff_t usb_offset, file_offset, file_offset_tmp;
unsigned int amount;
ssize_t nwritten;
ktime_t start, diff;
int rc, i;
if (curlun->ro) {
curlun->sense_data = SS_WRITE_PROTECTED;
return -EINVAL;
}
spin_lock(&curlun->filp->f_lock);
curlun->filp->f_flags &= ~O_SYNC; /* Default is not to wait */
spin_unlock(&curlun->filp->f_lock);
/*
* Get the starting Logical Block Address and check that it's
* not too big
*/
if (common->cmnd[0] == WRITE_6)
lba = get_unaligned_be24(&common->cmnd[1]);
else {
lba = get_unaligned_be32(&common->cmnd[2]);
/*
* We allow DPO (Disable Page Out = don't save data in the
* cache) and FUA (Force Unit Access = write directly to the
* medium). We don't implement DPO; we implement FUA by
* performing synchronous output.
*/
if (common->cmnd[1] & ~0x18) {
curlun->sense_data = <API key>;
return -EINVAL;
}
if (!curlun->nofua && (common->cmnd[1] & 0x08)) { /* FUA */
spin_lock(&curlun->filp->f_lock);
curlun->filp->f_flags |= O_SYNC;
spin_unlock(&curlun->filp->f_lock);
}
}
if (lba >= curlun->num_sectors) {
curlun->sense_data = <API key>;
return -EINVAL;
}
/* Carry out the file writes */
get_some_more = 1;
file_offset = usb_offset = ((loff_t) lba) << curlun->blkbits;
amount_left_to_req = common->data_size_from_cmnd;
<API key> = common->data_size_from_cmnd;
while (<API key> > 0) {
/* Queue a request for more data from the host */
bh = common->next_buffhd_to_fill;
if (bh->state == BUF_STATE_EMPTY && get_some_more) {
/*
* Figure out how much we want to get:
* Try to get the remaining amount,
* but not more than the buffer size.
*/
amount = min(amount_left_to_req, FSG_BUFLEN);
/* Beyond the end of the backing file? */
if (usb_offset >= curlun->file_length) {
get_some_more = 0;
curlun->sense_data =
<API key>;
curlun->sense_data_info =
usb_offset >> curlun->blkbits;
curlun->info_valid = 1;
continue;
}
/* Get the next buffer */
usb_offset += amount;
common->usb_amount_left -= amount;
amount_left_to_req -= amount;
if (amount_left_to_req == 0)
get_some_more = 0;
/*
* Except at the end of the transfer, amount will be
* equal to the buffer size, which is divisible by
* the bulk-out maxpacket size.
*/
<API key>(common, bh, amount);
if (!start_out_transfer(common, bh))
/* Dunno what to do if common->fsg is NULL */
return -EIO;
common->next_buffhd_to_fill = bh->next;
continue;
}
/* Write the received data to the backing file */
bh = common-><API key>;
if (bh->state == BUF_STATE_EMPTY && !get_some_more)
break; /* We stopped early */
/*
* If the csw packet is already submmitted to the hardware,
* by marking the state of buffer as full, then by checking
* the residue, we make sure that this csw packet is not
* written on to the storage media.
*/
if (bh->state == BUF_STATE_FULL && common->residue) {
smp_rmb();
common-><API key> = bh->next;
bh->state = BUF_STATE_EMPTY;
/* Did something go wrong with the transfer? */
if (bh->outreq->status != 0) {
curlun->sense_data = <API key>;
curlun->sense_data_info =
file_offset >> curlun->blkbits;
curlun->info_valid = 1;
break;
}
amount = bh->outreq->actual;
if (curlun->file_length - file_offset < amount) {
LERROR(curlun,
"write %u @ %llu beyond end %llu\n",
amount, (unsigned long long)file_offset,
(unsigned long long)curlun->file_length);
amount = curlun->file_length - file_offset;
}
/* Don't accept excess data. The spec doesn't say
* what to do in this case. We'll ignore the error.
*/
amount = min(amount, bh-><API key>);
/* Don't write a partial block */
amount = round_down(amount, curlun->blksize);
if (amount == 0)
goto empty_write;
/* Perform the write */
file_offset_tmp = file_offset;
start = ktime_get();
mod_timer(&common->vfs_timer, jiffies +
msecs_to_jiffies(<API key>));
nwritten = vfs_write(curlun->filp,
(char __user *)bh->buf,
amount, &file_offset_tmp);
del_timer_sync(&common->vfs_timer);
VLDBG(curlun, "file write %u @ %llu -> %d\n", amount,
(unsigned long long)file_offset, (int)nwritten);
diff = ktime_sub(ktime_get(), start);
curlun->perf.wbytes += nwritten;
curlun->perf.wtime =
ktime_add(curlun->perf.wtime, diff);
if (signal_pending(current))
return -EINTR; /* Interrupted! */
if (nwritten < 0) {
LDBG(curlun, "error in file write: %d\n",
(int)nwritten);
nwritten = 0;
} else if (nwritten < amount) {
LDBG(curlun, "partial file write: %d/%u\n",
(int)nwritten, amount);
nwritten = round_down(nwritten, curlun->blksize);
}
file_offset += nwritten;
<API key> -= nwritten;
common->residue -= nwritten;
/* If an error occurred, report it and its position */
if (nwritten < amount) {
curlun->sense_data = SS_WRITE_ERROR;
curlun->sense_data_info =
file_offset >> curlun->blkbits;
curlun->info_valid = 1;
<API key> = 1;
goto write_error;
break;
}
write_error:
if ((nwritten == amount) && !csw_sent) {
if (<API key>)
break;
/*
* If residue still exists and nothing left to
* write, device must send correct residue to
* host in this case.
*/
if (!<API key> && common->residue) {
must_report_residue = 1;
break;
}
/*
* Check if any of the buffer is in the
* busy state, if any buffer is in busy state,
* means the complete data is not received
* yet from the host. So there is no point in
* csw right away without the complete data.
*/
for (i = 0; i < common->fsg_num_buffers; i++) {
if (common->buffhds[i].state ==
BUF_STATE_BUSY)
break;
}
if (!amount_left_to_req &&
i == common->fsg_num_buffers) {
csw_sent = 1;
send_status(common);
}
}
empty_write:
/* Did the host decide to stop early? */
if (bh->outreq->actual < bh-><API key>) {
common-><API key> = 1;
break;
}
continue;
}
/* Wait for something to happen */
rc = sleep_thread(common, false);
if (rc)
return rc;
}
return -EIO; /* No default reply */
}
static int <API key>(struct fsg_common *common)
{
struct fsg_lun *curlun = common->curlun;
int rc;
/* We ignore the requested LBA and write out all file's
* dirty data buffers. */
mod_timer(&common->vfs_timer, jiffies +
msecs_to_jiffies(<API key>));
rc = fsg_lun_fsync_sub(curlun);
if (rc)
curlun->sense_data = SS_WRITE_ERROR;
del_timer_sync(&common->vfs_timer);
return 0;
}
static void invalidate_sub(struct fsg_lun *curlun)
{
struct file *filp = curlun->filp;
struct inode *inode = file_inode(filp);
unsigned long rc;
rc = <API key>(inode->i_mapping, 0, -1);
VLDBG(curlun, "<API key> -> %ld\n", rc);
}
static int do_verify(struct fsg_common *common)
{
struct fsg_lun *curlun = common->curlun;
u32 lba;
u32 verification_length;
struct fsg_buffhd *bh = common->next_buffhd_to_fill;
loff_t file_offset, file_offset_tmp;
u32 amount_left;
unsigned int amount;
ssize_t nread;
/*
* Get the starting Logical Block Address and check that it's
* not too big.
*/
lba = get_unaligned_be32(&common->cmnd[2]);
if (lba >= curlun->num_sectors) {
curlun->sense_data = <API key>;
return -EINVAL;
}
/*
* We allow DPO (Disable Page Out = don't save data in the
* cache) but we don't implement it.
*/
if (common->cmnd[1] & ~0x10) {
curlun->sense_data = <API key>;
return -EINVAL;
}
verification_length = get_unaligned_be16(&common->cmnd[7]);
if (unlikely(verification_length == 0))
return -EIO; /* No default reply */
/* Prepare to carry out the file verify */
amount_left = verification_length << curlun->blkbits;
file_offset = ((loff_t) lba) << curlun->blkbits;
/* Write out all the dirty buffers before invalidating them */
mod_timer(&common->vfs_timer, jiffies +
msecs_to_jiffies(<API key>));
fsg_lun_fsync_sub(curlun);
del_timer_sync(&common->vfs_timer);
if (signal_pending(current))
return -EINTR;
invalidate_sub(curlun);
if (signal_pending(current))
return -EINTR;
/* Just try to read the requested blocks */
while (amount_left > 0) {
/*
* Figure out how much we need to read:
* Try to read the remaining amount, but not more than
* the buffer size.
* And don't try to read past the end of the file.
*/
amount = min(amount_left, FSG_BUFLEN);
amount = min((loff_t)amount,
curlun->file_length - file_offset);
if (amount == 0) {
curlun->sense_data =
<API key>;
curlun->sense_data_info =
file_offset >> curlun->blkbits;
curlun->info_valid = 1;
break;
}
/* Perform the read */
file_offset_tmp = file_offset;
mod_timer(&common->vfs_timer, jiffies +
msecs_to_jiffies(<API key>));
nread = vfs_read(curlun->filp,
(char __user *) bh->buf,
amount, &file_offset_tmp);
del_timer_sync(&common->vfs_timer);
VLDBG(curlun, "file read %u @ %llu -> %d\n", amount,
(unsigned long long) file_offset,
(int) nread);
if (signal_pending(current))
return -EINTR;
if (nread < 0) {
LDBG(curlun, "error in file verify: %d\n", (int)nread);
nread = 0;
} else if (nread < amount) {
LDBG(curlun, "partial file verify: %d/%u\n",
(int)nread, amount);
nread = round_down(nread, curlun->blksize);
}
if (nread == 0) {
curlun->sense_data = <API key>;
curlun->sense_data_info =
file_offset >> curlun->blkbits;
curlun->info_valid = 1;
break;
}
file_offset += nread;
amount_left -= nread;
}
return 0;
}
static int do_inquiry(struct fsg_common *common, struct fsg_buffhd *bh)
{
struct fsg_lun *curlun = common->curlun;
u8 *buf = (u8 *) bh->buf;
if (!curlun) { /* Unsupported LUNs are okay */
common->bad_lun_okay = 1;
memset(buf, 0, 36);
buf[0] = 0x7f; /* Unsupported, no device-type */
buf[4] = 31; /* Additional length */
return 36;
}
buf[0] = curlun->cdrom ? TYPE_ROM : TYPE_DISK;
buf[1] = curlun->removable ? 0x80 : 0;
buf[2] = 2; /* ANSI SCSI level 2 */
buf[3] = 2; /* SCSI-2 INQUIRY data format */
buf[4] = 31; /* Additional length */
buf[5] = 0; /* No special options */
buf[6] = 0;
buf[7] = 0;
memcpy(buf + 8, common->inquiry_string, sizeof common->inquiry_string);
return 36;
}
static int do_request_sense(struct fsg_common *common, struct fsg_buffhd *bh)
{
struct fsg_lun *curlun = common->curlun;
u8 *buf = (u8 *) bh->buf;
u32 sd, sdinfo;
int valid;
/*
* From the SCSI-2 spec., section 7.9 (Unit attention condition):
*
* If a REQUEST SENSE command is received from an initiator
* with a pending unit attention condition (before the target
* generates the contingent allegiance condition), then the
* target shall either:
* a) report any pending sense data and preserve the unit
* attention condition on the logical unit, or,
* b) report the unit attention condition, may discard any
* pending sense data, and clear the unit attention
* condition on the logical unit for that initiator.
*
* FSG normally uses option a); enable this code to use option b).
*/
#if 0
if (curlun && curlun->unit_attention_data != SS_NO_SENSE) {
curlun->sense_data = curlun->unit_attention_data;
curlun->unit_attention_data = SS_NO_SENSE;
}
#endif
if (!curlun) { /* Unsupported LUNs are okay */
common->bad_lun_okay = 1;
sd = <API key>;
sdinfo = 0;
valid = 0;
} else {
sd = curlun->sense_data;
sdinfo = curlun->sense_data_info;
valid = curlun->info_valid << 7;
curlun->sense_data = SS_NO_SENSE;
curlun->sense_data_info = 0;
curlun->info_valid = 0;
}
memset(buf, 0, 18);
buf[0] = valid | 0x70; /* Valid, current error */
buf[2] = SK(sd);
put_unaligned_be32(sdinfo, &buf[3]); /* Sense information */
buf[7] = 18 - 8; /* Additional sense length */
buf[12] = ASC(sd);
buf[13] = ASCQ(sd);
return 18;
}
static int do_read_capacity(struct fsg_common *common, struct fsg_buffhd *bh)
{
struct fsg_lun *curlun = common->curlun;
u32 lba = get_unaligned_be32(&common->cmnd[2]);
int pmi = common->cmnd[8];
u8 *buf = (u8 *)bh->buf;
/* Check the PMI and LBA fields */
if (pmi > 1 || (pmi == 0 && lba != 0)) {
curlun->sense_data = <API key>;
return -EINVAL;
}
put_unaligned_be32(curlun->num_sectors - 1, &buf[0]);
/* Max logical block */
put_unaligned_be32(curlun->blksize, &buf[4]);/* Block length */
return 8;
}
static int do_read_header(struct fsg_common *common, struct fsg_buffhd *bh)
{
struct fsg_lun *curlun = common->curlun;
int msf = common->cmnd[1] & 0x02;
u32 lba = get_unaligned_be32(&common->cmnd[2]);
u8 *buf = (u8 *)bh->buf;
if (common->cmnd[1] & ~0x02) { /* Mask away MSF */
curlun->sense_data = <API key>;
return -EINVAL;
}
if (lba >= curlun->num_sectors) {
curlun->sense_data = <API key>;
return -EINVAL;
}
memset(buf, 0, 8);
buf[0] = 0x01; /* 2048 bytes of user data, rest is EC */
store_cdrom_address(&buf[4], msf, lba);
return 8;
}
static int do_read_toc(struct fsg_common *common, struct fsg_buffhd *bh)
{
struct fsg_lun *curlun = common->curlun;
int msf = common->cmnd[1] & 0x02;
int start_track = common->cmnd[6];
u8 *buf = (u8 *)bh->buf;
if ((common->cmnd[1] & ~0x02) != 0 || /* Mask away MSF */
start_track > 1) {
curlun->sense_data = <API key>;
return -EINVAL;
}
memset(buf, 0, 20);
buf[1] = (20-2); /* TOC data length */
buf[2] = 1; /* First track number */
buf[3] = 1; /* Last track number */
buf[5] = 0x16; /* Data track, copying allowed */
buf[6] = 0x01; /* Only track is number 1 */
store_cdrom_address(&buf[8], msf, 0);
buf[13] = 0x16; /* Lead-out track is data */
buf[14] = 0xAA; /* Lead-out track number */
store_cdrom_address(&buf[16], msf, curlun->num_sectors);
return 20;
}
static int do_mode_sense(struct fsg_common *common, struct fsg_buffhd *bh)
{
struct fsg_lun *curlun = common->curlun;
int mscmnd = common->cmnd[0];
u8 *buf = (u8 *) bh->buf;
u8 *buf0 = buf;
int pc, page_code;
int changeable_values, all_pages;
int valid_page = 0;
int len, limit;
if ((common->cmnd[1] & ~0x08) != 0) { /* Mask away DBD */
curlun->sense_data = <API key>;
return -EINVAL;
}
pc = common->cmnd[2] >> 6;
page_code = common->cmnd[2] & 0x3f;
if (pc == 3) {
curlun->sense_data = <API key>;
return -EINVAL;
}
changeable_values = (pc == 1);
all_pages = (page_code == 0x3f);
/*
* Write the mode parameter header. Fixed values are: default
* medium type, no cache control (DPOFUA), and no block descriptors.
* The only variable value is the WriteProtect bit. We will fill in
* the mode data length later.
*/
memset(buf, 0, 8);
if (mscmnd == MODE_SENSE) {
buf[2] = (curlun->ro ? 0x80 : 0x00); /* WP, DPOFUA */
buf += 4;
limit = 255;
} else { /* MODE_SENSE_10 */
buf[3] = (curlun->ro ? 0x80 : 0x00); /* WP, DPOFUA */
buf += 8;
limit = 65535; /* Should really be FSG_BUFLEN */
}
/* No block descriptors */
/*
* The mode pages, in numerical order. The only page we support
* is the Caching page.
*/
if (page_code == 0x08 || all_pages) {
valid_page = 1;
buf[0] = 0x08; /* Page code */
buf[1] = 10; /* Page length */
memset(buf+2, 0, 10); /* None of the fields are changeable */
if (!changeable_values) {
buf[2] = 0x04; /* Write cache enable, */
/* Read cache not disabled */
/* No cache retention priorities */
put_unaligned_be16(0xffff, &buf[4]);
/* Don't disable prefetch */
/* Minimum prefetch = 0 */
put_unaligned_be16(0xffff, &buf[8]);
/* Maximum prefetch */
put_unaligned_be16(0xffff, &buf[10]);
/* Maximum prefetch ceiling */
}
buf += 12;
}
/*
* Check that a valid page was requested and the mode data length
* isn't too long.
*/
len = buf - buf0;
if (!valid_page || len > limit) {
curlun->sense_data = <API key>;
return -EINVAL;
}
/* Store the mode data length */
if (mscmnd == MODE_SENSE)
buf0[0] = len - 1;
else
put_unaligned_be16(len - 2, buf0);
return len;
}
static int do_start_stop(struct fsg_common *common)
{
struct fsg_lun *curlun = common->curlun;
int loej, start;
if (!curlun) {
return -EINVAL;
} else if (!curlun->removable) {
curlun->sense_data = SS_INVALID_COMMAND;
return -EINVAL;
} else if ((common->cmnd[1] & ~0x01) != 0 || /* Mask away Immed */
(common->cmnd[4] & ~0x03) != 0) { /* Mask LoEj, Start */
curlun->sense_data = <API key>;
return -EINVAL;
}
loej = common->cmnd[4] & 0x02;
start = common->cmnd[4] & 0x01;
/*
* Our emulation doesn't support mounting; the medium is
* available for use as soon as it is loaded.
*/
if (start) {
if (!fsg_lun_is_open(curlun)) {
curlun->sense_data = <API key>;
return -EINVAL;
}
return 0;
}
/* Are we allowed to unload the media? */
if (curlun-><API key>) {
LDBG(curlun, "unload attempt prevented\n");
curlun->sense_data = <API key>;
return -EINVAL;
}
if (!loej)
return 0;
up_read(&common->filesem);
down_write(&common->filesem);
fsg_lun_close(curlun);
up_write(&common->filesem);
down_read(&common->filesem);
return 0;
}
static int do_prevent_allow(struct fsg_common *common)
{
struct fsg_lun *curlun = common->curlun;
int prevent;
if (!common->curlun) {
return -EINVAL;
} else if (!common->curlun->removable) {
common->curlun->sense_data = SS_INVALID_COMMAND;
return -EINVAL;
}
prevent = common->cmnd[4] & 0x01;
if ((common->cmnd[4] & ~0x01) != 0) { /* Mask away Prevent */
curlun->sense_data = <API key>;
return -EINVAL;
}
if (!curlun->nofua && curlun-><API key> && !prevent) {
mod_timer(&common->vfs_timer, jiffies +
msecs_to_jiffies(<API key>));
fsg_lun_fsync_sub(curlun);
del_timer_sync(&common->vfs_timer);
}
curlun-><API key> = prevent;
return 0;
}
static int <API key>(struct fsg_common *common,
struct fsg_buffhd *bh)
{
struct fsg_lun *curlun = common->curlun;
u8 *buf = (u8 *) bh->buf;
buf[0] = buf[1] = buf[2] = 0;
buf[3] = 8; /* Only the Current/Maximum Capacity Descriptor */
buf += 4;
put_unaligned_be32(curlun->num_sectors, &buf[0]);
/* Number of blocks */
put_unaligned_be32(curlun->blksize, &buf[4]);/* Block length */
buf[4] = 0x02; /* Current capacity */
return 12;
}
static int do_mode_select(struct fsg_common *common, struct fsg_buffhd *bh)
{
struct fsg_lun *curlun = common->curlun;
/* We don't support MODE SELECT */
if (curlun)
curlun->sense_data = SS_INVALID_COMMAND;
return -EINVAL;
}
static int <API key>(struct fsg_dev *fsg)
{
int rc;
rc = fsg_set_halt(fsg, fsg->bulk_in);
if (rc == -EAGAIN)
VDBG(fsg, "delayed bulk-in endpoint halt\n");
while (rc != 0) {
if (rc != -EAGAIN) {
WARNING(fsg, "usb_ep_set_halt -> %d\n", rc);
rc = 0;
break;
}
/* Wait for a short time and then try again */
if (<API key>(100) != 0)
return -EINTR;
rc = usb_ep_set_halt(fsg->bulk_in);
}
return rc;
}
static int <API key>(struct fsg_dev *fsg)
{
int rc;
DBG(fsg, "bulk-in set wedge\n");
rc = usb_ep_set_wedge(fsg->bulk_in);
if (rc == -EAGAIN)
VDBG(fsg, "delayed bulk-in endpoint wedge\n");
while (rc != 0) {
if (rc != -EAGAIN) {
WARNING(fsg, "usb_ep_set_wedge -> %d\n", rc);
rc = 0;
break;
}
/* Wait for a short time and then try again */
if (<API key>(100) != 0)
return -EINTR;
rc = usb_ep_set_wedge(fsg->bulk_in);
}
return rc;
}
static int throw_away_data(struct fsg_common *common)
{
struct fsg_buffhd *bh;
u32 amount;
int rc;
for (bh = common-><API key>;
bh->state != BUF_STATE_EMPTY || common->usb_amount_left > 0;
bh = common-><API key>) {
/* Throw away the data in a filled buffer */
if (bh->state == BUF_STATE_FULL) {
smp_rmb();
bh->state = BUF_STATE_EMPTY;
common-><API key> = bh->next;
/* A short packet or an error ends everything */
if (bh->outreq->actual < bh-><API key> ||
bh->outreq->status != 0) {
raise_exception(common,
<API key>);
return -EINTR;
}
continue;
}
/* Try to submit another request if we need one */
bh = common->next_buffhd_to_fill;
if (bh->state == BUF_STATE_EMPTY
&& common->usb_amount_left > 0) {
amount = min(common->usb_amount_left, FSG_BUFLEN);
/*
* Except at the end of the transfer, amount will be
* equal to the buffer size, which is divisible by
* the bulk-out maxpacket size.
*/
<API key>(common, bh, amount);
if (!start_out_transfer(common, bh))
/* Dunno what to do if common->fsg is NULL */
return -EIO;
common->next_buffhd_to_fill = bh->next;
common->usb_amount_left -= amount;
continue;
}
/* Otherwise wait for something to happen */
rc = sleep_thread(common, true);
if (rc)
return rc;
}
return 0;
}
static int finish_reply(struct fsg_common *common)
{
struct fsg_buffhd *bh = common->next_buffhd_to_fill;
int rc = 0;
switch (common->data_dir) {
case DATA_DIR_NONE:
break; /* Nothing to send */
/*
* If we don't know whether the host wants to read or write,
* this must be CB or CBI with an unknown command. We mustn't
* try to send or receive any data. So stall both bulk pipes
* if we can and wait for a reset.
*/
case DATA_DIR_UNKNOWN:
if (!common->can_stall) {
/* Nothing */
} else if (fsg_is_set(common)) {
fsg_set_halt(common->fsg, common->fsg->bulk_out);
rc = <API key>(common->fsg);
} else {
/* Don't know what to do if common->fsg is NULL */
rc = -EIO;
}
break;
/* All but the last buffer of data must have already been sent */
case DATA_DIR_TO_HOST:
if (common->data_size == 0) {
/* Nothing to send */
/* Don't know what to do if common->fsg is NULL */
} else if (!fsg_is_set(common)) {
rc = -EIO;
/* If there's no residue, simply send the last buffer */
} else if (common->residue == 0) {
bh->inreq->zero = 0;
if (!start_in_transfer(common, bh))
return -EIO;
common->next_buffhd_to_fill = bh->next;
/*
* For Bulk-only, mark the end of the data with a short
* packet. If we are allowed to stall, halt the bulk-in
* endpoint. (Note: This violates the Bulk-Only Transport
* specification, which requires us to pad the data if we
* don't halt the endpoint. Presumably nobody will mind.)
*/
} else {
bh->inreq->zero = 1;
if (!start_in_transfer(common, bh))
rc = -EIO;
common->next_buffhd_to_fill = bh->next;
if (common->can_stall)
rc = <API key>(common->fsg);
}
break;
/*
* We have processed all we want from the data the host has sent.
* There may still be outstanding bulk-out requests.
*/
case DATA_DIR_FROM_HOST:
if (common->residue == 0) {
/* Nothing to receive */
/* Did the host stop sending unexpectedly early? */
} else if (common-><API key>) {
raise_exception(common, <API key>);
rc = -EINTR;
/*
* We haven't processed all the incoming data. Even though
* we may be allowed to stall, doing so would cause a race.
* The controller may already have ACK'ed all the remaining
* bulk-out packets, in which case the host wouldn't see a
* STALL. Not realizing the endpoint was halted, it wouldn't
* clear the halt -- leading to problems later on.
*/
#if 0
} else if (common->can_stall) {
if (fsg_is_set(common))
fsg_set_halt(common->fsg,
common->fsg->bulk_out);
raise_exception(common, <API key>);
rc = -EINTR;
#endif
/*
* We can't stall. Read in the excess data and throw it
* all away.
*/
} else {
rc = throw_away_data(common);
}
break;
}
return rc;
}
static int send_status(struct fsg_common *common)
{
struct fsg_lun *curlun = common->curlun;
struct fsg_buffhd *bh;
struct bulk_cs_wrap *csw;
int rc;
u8 status = US_BULK_STAT_OK;
u32 sd, sdinfo = 0;
/* Wait for the next buffer to become available */
spin_lock_irq(&common->lock);
bh = common->next_buffhd_to_fill;
while (bh->state != BUF_STATE_EMPTY) {
spin_unlock_irq(&common->lock);
rc = sleep_thread(common, true);
if (rc)
return rc;
spin_lock_irq(&common->lock);
}
spin_unlock_irq(&common->lock);
if (curlun) {
sd = curlun->sense_data;
sdinfo = curlun->sense_data_info;
} else if (common->bad_lun_okay)
sd = SS_NO_SENSE;
else
sd = <API key>;
if (common->phase_error) {
DBG(common, "sending phase-error status\n");
status = US_BULK_STAT_PHASE;
sd = SS_INVALID_COMMAND;
} else if (sd != SS_NO_SENSE) {
DBG(common, "sending command-failure status\n");
status = US_BULK_STAT_FAIL;
VDBG(common, " sense data: SK x%02x, ASC x%02x, ASCQ x%02x;"
" info x%x\n",
SK(sd), ASC(sd), ASCQ(sd), sdinfo);
}
/* Store and send the Bulk-only CSW */
csw = (void *)bh->buf;
csw->Signature = cpu_to_le32(US_BULK_CS_SIGN);
csw->Tag = common->tag;
csw->Residue = cpu_to_le32(common->residue);
/*
* Since csw is being sent early, before
* writing on to storage media, need to set
* residue to zero,assuming that write will succeed.
*/
if (<API key> || must_report_residue) {
<API key> = 0;
must_report_residue = 0;
}
else
csw->Residue = 0;
csw->Status = status;
bh->inreq->length = US_BULK_CS_WRAP_LEN;
bh->inreq->zero = 0;
if (!start_in_transfer(common, bh))
/* Don't know what to do if common->fsg is NULL */
return -EIO;
common->next_buffhd_to_fill = bh->next;
return 0;
}
/*
* Check whether the command is properly formed and whether its data size
* and direction agree with the values we already have.
*/
static int check_command(struct fsg_common *common, int cmnd_size,
enum data_direction data_dir, unsigned int mask,
int needs_medium, const char *name)
{
int i;
unsigned int lun = common->cmnd[1] >> 5;
static const char dirletter[4] = {'u', 'o', 'i', 'n'};
char hdlen[20];
struct fsg_lun *curlun;
hdlen[0] = 0;
if (common->data_dir != DATA_DIR_UNKNOWN)
sprintf(hdlen, ", H%c=%u", dirletter[(int) common->data_dir],
common->data_size);
VDBG(common, "SCSI command: %s; Dc=%d, D%c=%u; Hc=%d%s\n",
name, cmnd_size, dirletter[(int) data_dir],
common->data_size_from_cmnd, common->cmnd_size, hdlen);
/*
* We can't reply at all until we know the correct data direction
* and size.
*/
if (common->data_size_from_cmnd == 0)
data_dir = DATA_DIR_NONE;
if (common->data_size < common->data_size_from_cmnd) {
/*
* Host data size < Device data size is a phase error.
* Carry out the command, but only transfer as much as
* we are allowed.
*/
common->data_size_from_cmnd = common->data_size;
common->phase_error = 1;
}
common->residue = common->data_size;
common->usb_amount_left = common->data_size;
/* Conflicting data directions is a phase error */
if (common->data_dir != data_dir && common->data_size_from_cmnd > 0) {
common->phase_error = 1;
return -EINVAL;
}
/* Verify the length of the command itself */
if (cmnd_size != common->cmnd_size) {
/*
* Special case workaround: There are plenty of buggy SCSI
* implementations. Many have issues with cbw->Length
* field passing a wrong command size. For those cases we
* always try to work around the problem by using the length
* sent by the host side provided it is at least as large
* as the correct command length.
* Examples of such cases would be MS-Windows, which issues
* REQUEST SENSE with cbw->Length == 12 where it should
* be 6, and xbox360 issuing INQUIRY, TEST UNIT READY and
* REQUEST SENSE with cbw->Length == 10 where it should
* be 6 as well.
*/
if (cmnd_size <= common->cmnd_size) {
DBG(common, "%s is buggy! Expected length %d "
"but we got %d\n", name,
cmnd_size, common->cmnd_size);
cmnd_size = common->cmnd_size;
} else {
common->phase_error = 1;
return -EINVAL;
}
}
/* Check that the LUN values are consistent */
if (common->lun != lun)
DBG(common, "using LUN %u from CBW, not LUN %u from CDB\n",
common->lun, lun);
/* Check the LUN */
curlun = common->curlun;
if (curlun) {
if (common->cmnd[0] != REQUEST_SENSE) {
curlun->sense_data = SS_NO_SENSE;
curlun->sense_data_info = 0;
curlun->info_valid = 0;
}
} else {
common->bad_lun_okay = 0;
/*
* INQUIRY and REQUEST SENSE commands are explicitly allowed
* to use unsupported LUNs; all others may not.
*/
if (common->cmnd[0] != INQUIRY &&
common->cmnd[0] != REQUEST_SENSE) {
DBG(common, "unsupported LUN %u\n", common->lun);
return -EINVAL;
}
}
/*
* If a unit attention condition exists, only INQUIRY and
* REQUEST SENSE commands are allowed; anything else must fail.
*/
if (curlun && curlun->unit_attention_data != SS_NO_SENSE &&
common->cmnd[0] != INQUIRY &&
common->cmnd[0] != REQUEST_SENSE) {
curlun->sense_data = curlun->unit_attention_data;
curlun->unit_attention_data = SS_NO_SENSE;
return -EINVAL;
}
/* Check that only command bytes listed in the mask are non-zero */
common->cmnd[1] &= 0x1f; /* Mask away the LUN */
for (i = 1; i < cmnd_size; ++i) {
if (common->cmnd[i] && !(mask & (1 << i))) {
if (curlun)
curlun->sense_data = <API key>;
return -EINVAL;
}
}
/* If the medium isn't mounted and the command needs to access
* it, return an error. */
if (curlun && !fsg_lun_is_open(curlun) && needs_medium) {
curlun->sense_data = <API key>;
return -EINVAL;
}
return 0;
}
/* wrapper of check_command for data size in blocks handling */
static int <API key>(struct fsg_common *common,
int cmnd_size, enum data_direction data_dir,
unsigned int mask, int needs_medium, const char *name)
{
if (common->curlun)
common->data_size_from_cmnd <<= common->curlun->blkbits;
return check_command(common, cmnd_size, data_dir,
mask, needs_medium, name);
}
static int do_scsi_command(struct fsg_common *common)
{
struct fsg_buffhd *bh;
int rc;
int reply = -EINVAL;
int i;
static char unknown[16];
dump_cdb(common);
/* Wait for the next buffer to become available for data or status */
spin_lock_irq(&common->lock);
bh = common->next_buffhd_to_fill;
common-><API key> = bh;
while (bh->state != BUF_STATE_EMPTY) {
spin_unlock_irq(&common->lock);
rc = sleep_thread(common, true);
if (rc)
return rc;
spin_lock_irq(&common->lock);
}
spin_unlock_irq(&common->lock);
common->phase_error = 0;
common-><API key> = 0;
down_read(&common->filesem); /* We're using the backing file */
switch (common->cmnd[0]) {
case INQUIRY:
common->data_size_from_cmnd = common->cmnd[4];
reply = check_command(common, 6, DATA_DIR_TO_HOST,
(1<<4), 0,
"INQUIRY");
if (reply == 0)
reply = do_inquiry(common, bh);
break;
case MODE_SELECT:
common->data_size_from_cmnd = common->cmnd[4];
reply = check_command(common, 6, DATA_DIR_FROM_HOST,
(1<<1) | (1<<4), 0,
"MODE SELECT(6)");
if (reply == 0)
reply = do_mode_select(common, bh);
break;
case MODE_SELECT_10:
common->data_size_from_cmnd =
get_unaligned_be16(&common->cmnd[7]);
reply = check_command(common, 10, DATA_DIR_FROM_HOST,
(1<<1) | (3<<7), 0,
"MODE SELECT(10)");
if (reply == 0)
reply = do_mode_select(common, bh);
break;
case MODE_SENSE:
common->data_size_from_cmnd = common->cmnd[4];
reply = check_command(common, 6, DATA_DIR_TO_HOST,
(1<<1) | (1<<2) | (1<<4), 0,
"MODE SENSE(6)");
if (reply == 0)
reply = do_mode_sense(common, bh);
break;
case MODE_SENSE_10:
common->data_size_from_cmnd =
get_unaligned_be16(&common->cmnd[7]);
reply = check_command(common, 10, DATA_DIR_TO_HOST,
(1<<1) | (1<<2) | (3<<7), 0,
"MODE SENSE(10)");
if (reply == 0)
reply = do_mode_sense(common, bh);
break;
case <API key>:
common->data_size_from_cmnd = 0;
reply = check_command(common, 6, DATA_DIR_NONE,
(1<<4), 0,
"PREVENT-ALLOW MEDIUM REMOVAL");
if (reply == 0)
reply = do_prevent_allow(common);
break;
case READ_6:
i = common->cmnd[4];
common->data_size_from_cmnd = (i == 0) ? 256 : i;
reply = <API key>(common, 6,
DATA_DIR_TO_HOST,
(7<<1) | (1<<4), 1,
"READ(6)");
if (reply == 0)
reply = do_read(common);
break;
case READ_10:
common->data_size_from_cmnd =
get_unaligned_be16(&common->cmnd[7]);
reply = <API key>(common, 10,
DATA_DIR_TO_HOST,
(1<<1) | (0xf<<2) | (3<<7), 1,
"READ(10)");
if (reply == 0)
reply = do_read(common);
break;
case READ_12:
common->data_size_from_cmnd =
get_unaligned_be32(&common->cmnd[6]);
reply = <API key>(common, 12,
DATA_DIR_TO_HOST,
(1<<1) | (0xf<<2) | (0xf<<6), 1,
"READ(12)");
if (reply == 0)
reply = do_read(common);
break;
case READ_CAPACITY:
common->data_size_from_cmnd = 8;
reply = check_command(common, 10, DATA_DIR_TO_HOST,
(0xf<<2) | (1<<8), 1,
"READ CAPACITY");
if (reply == 0)
reply = do_read_capacity(common, bh);
break;
case READ_HEADER:
if (!common->curlun || !common->curlun->cdrom)
goto unknown_cmnd;
common->data_size_from_cmnd =
get_unaligned_be16(&common->cmnd[7]);
reply = check_command(common, 10, DATA_DIR_TO_HOST,
(3<<7) | (0x1f<<1), 1,
"READ HEADER");
if (reply == 0)
reply = do_read_header(common, bh);
break;
case READ_TOC:
if (!common->curlun || !common->curlun->cdrom)
goto unknown_cmnd;
common->data_size_from_cmnd =
get_unaligned_be16(&common->cmnd[7]);
reply = check_command(common, 10, DATA_DIR_TO_HOST,
(7<<6) | (1<<1), 1,
"READ TOC");
if (reply == 0)
reply = do_read_toc(common, bh);
break;
case <API key>:
common->data_size_from_cmnd =
get_unaligned_be16(&common->cmnd[7]);
reply = check_command(common, 10, DATA_DIR_TO_HOST,
(3<<7), 1,
"READ FORMAT CAPACITIES");
if (reply == 0)
reply = <API key>(common, bh);
break;
case REQUEST_SENSE:
common->data_size_from_cmnd = common->cmnd[4];
reply = check_command(common, 6, DATA_DIR_TO_HOST,
(1<<4), 0,
"REQUEST SENSE");
if (reply == 0)
reply = do_request_sense(common, bh);
break;
case START_STOP:
common->data_size_from_cmnd = 0;
reply = check_command(common, 6, DATA_DIR_NONE,
(1<<1) | (1<<4), 0,
"START-STOP UNIT");
if (reply == 0)
reply = do_start_stop(common);
break;
case SYNCHRONIZE_CACHE:
common->data_size_from_cmnd = 0;
reply = check_command(common, 10, DATA_DIR_NONE,
(0xf<<2) | (3<<7), 1,
"SYNCHRONIZE CACHE");
if (reply == 0)
reply = <API key>(common);
break;
case TEST_UNIT_READY:
common->data_size_from_cmnd = 0;
reply = check_command(common, 6, DATA_DIR_NONE,
0, 1,
"TEST UNIT READY");
break;
case VERIFY:
common->data_size_from_cmnd = 0;
reply = check_command(common, 10, DATA_DIR_NONE,
(1<<1) | (0xf<<2) | (3<<7), 1,
"VERIFY");
if (reply == 0)
reply = do_verify(common);
break;
case WRITE_6:
i = common->cmnd[4];
common->data_size_from_cmnd = (i == 0) ? 256 : i;
reply = <API key>(common, 6,
DATA_DIR_FROM_HOST,
(7<<1) | (1<<4), 1,
"WRITE(6)");
if (reply == 0)
reply = do_write(common);
break;
case WRITE_10:
common->data_size_from_cmnd =
get_unaligned_be16(&common->cmnd[7]);
reply = <API key>(common, 10,
DATA_DIR_FROM_HOST,
(1<<1) | (0xf<<2) | (3<<7), 1,
"WRITE(10)");
if (reply == 0)
reply = do_write(common);
break;
case WRITE_12:
common->data_size_from_cmnd =
get_unaligned_be32(&common->cmnd[6]);
reply = <API key>(common, 12,
DATA_DIR_FROM_HOST,
(1<<1) | (0xf<<2) | (0xf<<6), 1,
"WRITE(12)");
if (reply == 0)
reply = do_write(common);
break;
/*
* Some mandatory commands that we recognize but don't implement.
* They don't mean much in this setting. It's left as an exercise
* for anyone interested to implement RESERVE and RELEASE in terms
* of Posix locks.
*/
case FORMAT_UNIT:
case RELEASE:
case RESERVE:
case SEND_DIAGNOSTIC:
/* Fall through */
default:
unknown_cmnd:
common->data_size_from_cmnd = 0;
sprintf(unknown, "Unknown x%02x", common->cmnd[0]);
reply = check_command(common, common->cmnd_size,
DATA_DIR_UNKNOWN, ~0, 0, unknown);
if (reply == 0) {
common->curlun->sense_data = SS_INVALID_COMMAND;
reply = -EINVAL;
}
break;
}
up_read(&common->filesem);
if (reply == -EINTR || signal_pending(current))
return -EINTR;
/* Set up the single reply buffer for finish_reply() */
if (reply == -EINVAL)
reply = 0; /* Error reply length */
if (reply >= 0 && common->data_dir == DATA_DIR_TO_HOST) {
reply = min((u32)reply, common->data_size_from_cmnd);
bh->inreq->length = reply;
bh->state = BUF_STATE_FULL;
common->residue -= reply;
} /* Otherwise it's already set */
return 0;
}
static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
{
struct usb_request *req = bh->outreq;
struct bulk_cb_wrap *cbw = req->buf;
struct fsg_common *common = fsg->common;
/* Was this a real packet? Should it be ignored? */
if (req->status || test_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags))
return -EINVAL;
/* Is the CBW valid? */
if (req->actual != US_BULK_CB_WRAP_LEN ||
cbw->Signature != cpu_to_le32(
US_BULK_CB_SIGN)) {
DBG(fsg, "invalid CBW: len %u sig 0x%x\n",
req->actual,
le32_to_cpu(cbw->Signature));
/*
* The Bulk-only spec says we MUST stall the IN endpoint
* (6.6.1), so it's unavoidable. It also says we must
* retain this state until the next reset, but there's
* no way to tell the controller driver it should ignore
* Clear-Feature(HALT) requests.
*
* We aren't required to halt the OUT endpoint; instead
* we can simply accept and discard any data received
* until the next reset.
*/
<API key>(fsg);
set_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags);
return -EINVAL;
}
/* Is the CBW meaningful? */
if (cbw->Lun >= FSG_MAX_LUNS || cbw->Flags & ~US_BULK_FLAG_IN ||
cbw->Length <= 0 || cbw->Length > MAX_COMMAND_SIZE) {
DBG(fsg, "non-meaningful CBW: lun = %u, flags = 0x%x, "
"cmdlen %u\n",
cbw->Lun, cbw->Flags, cbw->Length);
/*
* We can do anything we want here, so let's stall the
* bulk pipes if we are allowed to.
*/
if (common->can_stall) {
fsg_set_halt(fsg, fsg->bulk_out);
<API key>(fsg);
}
return -EINVAL;
}
/* Save the command for later */
common->cmnd_size = cbw->Length;
memcpy(common->cmnd, cbw->CDB, common->cmnd_size);
if (cbw->Flags & US_BULK_FLAG_IN)
common->data_dir = DATA_DIR_TO_HOST;
else
common->data_dir = DATA_DIR_FROM_HOST;
common->data_size = le32_to_cpu(cbw->DataTransferLength);
if (common->data_size == 0)
common->data_dir = DATA_DIR_NONE;
common->lun = cbw->Lun;
if (common->lun < common->nluns)
common->curlun = common->luns[common->lun];
else
common->curlun = NULL;
common->tag = cbw->Tag;
return 0;
}
static int get_next_command(struct fsg_common *common)
{
struct fsg_buffhd *bh;
int rc = 0;
/* Wait for the next buffer to become available */
spin_lock_irq(&common->lock);
bh = common->next_buffhd_to_fill;
while (bh->state != BUF_STATE_EMPTY) {
spin_unlock_irq(&common->lock);
rc = sleep_thread(common, true);
if (rc)
return rc;
spin_lock_irq(&common->lock);
}
spin_unlock_irq(&common->lock);
/* Queue a request to read a Bulk-only CBW */
<API key>(common, bh, US_BULK_CB_WRAP_LEN);
if (!start_out_transfer(common, bh))
/* Don't know what to do if common->fsg is NULL */
return -EIO;
/*
* We will drain the buffer in software, which means we
* can reuse it for the next filling. No need to advance
* next_buffhd_to_fill.
*/
/* Wait for the CBW to arrive */
spin_lock_irq(&common->lock);
while (bh->state != BUF_STATE_FULL) {
spin_unlock_irq(&common->lock);
rc = sleep_thread(common, true);
if (rc)
return rc;
spin_lock_irq(&common->lock);
}
spin_unlock_irq(&common->lock);
smp_rmb();
rc = fsg_is_set(common) ? received_cbw(common->fsg, bh) : -EIO;
spin_lock_irq(&common->lock);
bh->state = BUF_STATE_EMPTY;
spin_unlock_irq(&common->lock);
return rc;
}
static int alloc_request(struct fsg_common *common, struct usb_ep *ep,
struct usb_request **preq)
{
*preq = <API key>(ep, GFP_ATOMIC);
if (*preq)
return 0;
ERROR(common, "can't allocate request for %s\n", ep->name);
return -ENOMEM;
}
/* Reset interface setting and re-init endpoint state (toggle etc). */
static int do_set_interface(struct fsg_common *common, struct fsg_dev *new_fsg)
{
struct fsg_dev *fsg;
int i, rc = 0;
if (common->running)
DBG(common, "reset interface\n");
reset:
/* Deallocate the requests */
if (common->fsg) {
fsg = common->fsg;
for (i = 0; i < common->fsg_num_buffers; ++i) {
struct fsg_buffhd *bh = &common->buffhds[i];
if (bh->inreq) {
usb_ep_free_request(fsg->bulk_in, bh->inreq);
bh->inreq = NULL;
}
if (bh->outreq) {
usb_ep_free_request(fsg->bulk_out, bh->outreq);
bh->outreq = NULL;
}
}
common->fsg = NULL;
wake_up(&common->fsg_wait);
}
common->running = 0;
if (!new_fsg || rc)
return rc;
common->fsg = new_fsg;
fsg = common->fsg;
/* Allocate the requests */
for (i = 0; i < common->fsg_num_buffers; ++i) {
struct fsg_buffhd *bh = &common->buffhds[i];
rc = alloc_request(common, fsg->bulk_in, &bh->inreq);
if (rc)
goto reset;
rc = alloc_request(common, fsg->bulk_out, &bh->outreq);
if (rc)
goto reset;
bh->inreq->buf = bh->outreq->buf = bh->buf;
bh->inreq->context = bh->outreq->context = bh;
bh->inreq->complete = bulk_in_complete;
bh->outreq->complete = bulk_out_complete;
}
common->running = 1;
for (i = 0; i < common->nluns; ++i)
if (common->luns[i])
common->luns[i]->unit_attention_data =
SS_RESET_OCCURRED;
return rc;
}
static int fsg_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
{
struct fsg_dev *fsg = fsg_from_func(f);
struct fsg_common *common = fsg->common;
int rc;
/* Enable the endpoints */
rc = config_ep_by_speed(common->gadget, &(fsg->function), fsg->bulk_in);
if (rc)
goto err_exit;
rc = usb_ep_enable(fsg->bulk_in);
if (rc)
goto err_exit;
fsg->bulk_in->driver_data = common;
fsg->bulk_in_enabled = 1;
rc = config_ep_by_speed(common->gadget, &(fsg->function),
fsg->bulk_out);
if (rc)
goto reset_bulk_int;
rc = usb_ep_enable(fsg->bulk_out);
if (rc)
goto reset_bulk_int;
fsg->bulk_out->driver_data = common;
fsg->bulk_out_enabled = 1;
common->bulk_out_maxpacket = usb_endpoint_maxp(fsg->bulk_out->desc);
clear_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags);
csw_sent = 0;
<API key> = 0;
fsg->common->new_fsg = fsg;
raise_exception(fsg->common, <API key>);
return <API key>;
reset_bulk_int:
usb_ep_disable(fsg->bulk_in);
fsg->bulk_in_enabled = 0;
err_exit:
return rc;
}
static void fsg_disable(struct usb_function *f)
{
struct fsg_dev *fsg = fsg_from_func(f);
/* Disable the endpoints */
if (fsg->bulk_in_enabled) {
usb_ep_disable(fsg->bulk_in);
fsg->bulk_in->driver_data = NULL;
fsg->bulk_in_enabled = 0;
}
if (fsg->bulk_out_enabled) {
usb_ep_disable(fsg->bulk_out);
fsg->bulk_out->driver_data = NULL;
fsg->bulk_out_enabled = 0;
}
fsg->common->new_fsg = NULL;
raise_exception(fsg->common, <API key>);
}
static void handle_exception(struct fsg_common *common)
{
siginfo_t info;
int i;
struct fsg_buffhd *bh;
enum fsg_state old_state;
struct fsg_lun *curlun;
unsigned int exception_req_tag;
unsigned long flags;
/*
* Clear the existing signals. Anything but SIGUSR1 is converted
* into a high-priority EXIT exception.
*/
for (;;) {
int sig =
dequeue_signal_lock(current, ¤t->blocked, &info);
if (!sig)
break;
if (sig != SIGUSR1) {
if (common->state < FSG_STATE_EXIT)
DBG(common, "Main thread exiting on signal\n");
WARN_ON(1);
pr_err("%s: signal(%d) received from PID(%d) UID(%d)\n",
__func__, sig, info.si_pid, info.si_uid);
raise_exception(common, FSG_STATE_EXIT);
}
}
/* Cancel all the pending transfers */
if (likely(common->fsg)) {
for (i = 0; i < common->fsg_num_buffers; ++i) {
bh = &common->buffhds[i];
if (bh->inreq_busy)
usb_ep_dequeue(common->fsg->bulk_in, bh->inreq);
if (bh->outreq_busy)
usb_ep_dequeue(common->fsg->bulk_out,
bh->outreq);
}
/* Wait until everything is idle */
for (;;) {
int num_active = 0;
spin_lock_irq(&common->lock);
for (i = 0; i < common->fsg_num_buffers; ++i) {
bh = &common->buffhds[i];
num_active += bh->inreq_busy + bh->outreq_busy;
}
spin_unlock_irq(&common->lock);
if (num_active == 0)
break;
if (sleep_thread(common, true))
return;
}
/* Clear out the controller's fifos */
if (common->fsg->bulk_in_enabled)
usb_ep_fifo_flush(common->fsg->bulk_in);
if (common->fsg->bulk_out_enabled)
usb_ep_fifo_flush(common->fsg->bulk_out);
}
/*
* Reset the I/O buffer states and pointers, the SCSI
* state, and the exception. Then invoke the handler.
*/
spin_lock_irqsave(&common->lock, flags);
for (i = 0; i < common->fsg_num_buffers; ++i) {
bh = &common->buffhds[i];
bh->state = BUF_STATE_EMPTY;
}
common->next_buffhd_to_fill = &common->buffhds[0];
common-><API key> = &common->buffhds[0];
exception_req_tag = common->exception_req_tag;
old_state = common->state;
if (old_state == <API key>)
common->state = <API key>;
else {
for (i = 0; i < common->nluns; ++i) {
curlun = common->luns[i];
if (!curlun)
continue;
curlun-><API key> = 0;
curlun->sense_data = SS_NO_SENSE;
curlun->unit_attention_data = SS_NO_SENSE;
curlun->sense_data_info = 0;
curlun->info_valid = 0;
}
common->state = FSG_STATE_IDLE;
}
<API key>(&common->lock, flags);
/* Carry out any extra actions required for the exception */
switch (old_state) {
case <API key>:
send_status(common);
spin_lock_irq(&common->lock);
if (common->state == <API key>)
common->state = FSG_STATE_IDLE;
spin_unlock_irq(&common->lock);
break;
case FSG_STATE_RESET:
/*
* In case we were forced against our will to halt a
* bulk endpoint, clear the halt now. (The SuperH UDC
* requires this.)
*/
if (!fsg_is_set(common))
break;
if (test_and_clear_bit(IGNORE_BULK_OUT,
&common->fsg->atomic_bitflags))
usb_ep_clear_halt(common->fsg->bulk_in);
if (common->ep0_req_tag == exception_req_tag) {
/* Complete the status stage */
if (common->cdev)
<API key>(common->cdev);
else
ep0_queue(common);
}
/*
* Technically this should go here, but it would only be
* a waste of time. Ditto for the INTERFACE_CHANGE and
* CONFIG_CHANGE cases.
*/
/* for (i = 0; i < common->nluns; ++i) */
/* if (common->luns[i]) */
/* common->luns[i]->unit_attention_data = */
/* SS_RESET_OCCURRED; */
break;
case <API key>:
do_set_interface(common, common->new_fsg);
if (common->new_fsg)
<API key>(common->cdev);
break;
case FSG_STATE_EXIT:
case <API key>:
do_set_interface(common, NULL); /* Free resources */
spin_lock_irq(&common->lock);
common->state = <API key>; /* Stop the thread */
spin_unlock_irq(&common->lock);
break;
case <API key>:
case <API key>:
case <API key>:
case <API key>:
case <API key>:
case FSG_STATE_IDLE:
break;
}
}
static int fsg_main_thread(void *common_)
{
struct fsg_common *common = common_;
/*
* Allow the thread to be killed by a signal, but set the signal mask
* to block everything but INT, TERM, KILL, and USR1.
*/
allow_signal(SIGINT);
allow_signal(SIGTERM);
allow_signal(SIGKILL);
allow_signal(SIGUSR1);
/* Allow the thread to be frozen */
set_freezable();
/*
* Arrange for userspace references to be interpreted as kernel
* pointers. That way we can pass a kernel pointer to a routine
* that expects a __user pointer and it will work okay.
*/
set_fs(get_ds());
/* The main loop */
while (common->state != <API key>) {
if (<API key>(common) || signal_pending(current)) {
handle_exception(common);
continue;
}
if (!common->running) {
sleep_thread(common, true);
continue;
}
if (get_next_command(common))
continue;
spin_lock_irq(&common->lock);
if (!<API key>(common))
common->state = <API key>;
spin_unlock_irq(&common->lock);
if (do_scsi_command(common) || finish_reply(common))
continue;
spin_lock_irq(&common->lock);
if (!<API key>(common))
common->state = <API key>;
spin_unlock_irq(&common->lock);
/*
* Since status is already sent for write scsi command,
* need to skip sending status once again if it is a
* write scsi command.
*/
if (csw_sent) {
csw_sent = 0;
continue;
}
if (send_status(common))
continue;
spin_lock_irq(&common->lock);
if (!<API key>(common))
common->state = FSG_STATE_IDLE;
spin_unlock_irq(&common->lock);
}
spin_lock_irq(&common->lock);
common->thread_task = NULL;
spin_unlock_irq(&common->lock);
if (!common->ops || !common->ops->thread_exits
|| common->ops->thread_exits(common) < 0) {
struct fsg_lun **curlun_it = common->luns;
unsigned i = common->nluns;
down_write(&common->filesem);
for (; i--; ++curlun_it) {
struct fsg_lun *curlun = *curlun_it;
if (!curlun || !fsg_lun_is_open(curlun))
continue;
fsg_lun_close(curlun);
curlun->unit_attention_data = <API key>;
}
up_write(&common->filesem);
}
/* Let fsg_unbind() know the thread has exited */
complete_and_exit(&common->thread_notifier, 0);
}
static ssize_t ro_show(struct device *dev, struct device_attribute *attr, char *buf)
{
struct fsg_lun *curlun = fsg_lun_from_dev(dev);
return fsg_show_ro(curlun, buf);
}
static ssize_t nofua_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
struct fsg_lun *curlun = fsg_lun_from_dev(dev);
return fsg_show_nofua(curlun, buf);
}
static ssize_t file_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
struct fsg_lun *curlun = fsg_lun_from_dev(dev);
struct rw_semaphore *filesem = dev_get_drvdata(dev);
return fsg_show_file(curlun, filesem, buf);
}
static ssize_t ro_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct fsg_lun *curlun = fsg_lun_from_dev(dev);
struct rw_semaphore *filesem = dev_get_drvdata(dev);
return fsg_store_ro(curlun, filesem, buf, count);
}
static ssize_t nofua_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct fsg_lun *curlun = fsg_lun_from_dev(dev);
return fsg_store_nofua(curlun, buf, count);
}
static ssize_t file_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct fsg_lun *curlun = fsg_lun_from_dev(dev);
struct rw_semaphore *filesem = dev_get_drvdata(dev);
return fsg_store_file(curlun, filesem, buf, count);
}
static DEVICE_ATTR_RW(ro);
static DEVICE_ATTR_RW(nofua);
static DEVICE_ATTR_RW(file);
static DEVICE_ATTR(perf, 0644, fsg_show_perf, fsg_store_perf);
static struct device_attribute dev_attr_ro_cdrom = __ATTR_RO(ro);
static struct device_attribute <API key> = __ATTR_RO(file);
static void fsg_common_release(struct kref *ref);
static void fsg_lun_release(struct device *dev)
{
/* Nothing needs to be done */
}
void fsg_common_get(struct fsg_common *common)
{
kref_get(&common->ref);
}
EXPORT_SYMBOL_GPL(fsg_common_get);
void fsg_common_put(struct fsg_common *common)
{
kref_put(&common->ref, fsg_common_release);
}
EXPORT_SYMBOL_GPL(fsg_common_put);
/* check if fsg_num_buffers is within a valid range */
static inline int <API key>(unsigned int fsg_num_buffers)
{
if (fsg_num_buffers >= 2 && fsg_num_buffers <= 4)
return 0;
pr_err("fsg_num_buffers %u is out of range (%d to %d)\n",
fsg_num_buffers, 2, 4);
return -EINVAL;
}
static struct fsg_common *fsg_common_setup(struct fsg_common *common)
{
if (!common) {
common = kzalloc(sizeof(*common), GFP_KERNEL);
if (!common)
return ERR_PTR(-ENOMEM);
common-><API key> = 1;
} else {
common-><API key> = 0;
}
init_rwsem(&common->filesem);
spin_lock_init(&common->lock);
kref_init(&common->ref);
init_completion(&common->thread_notifier);
init_waitqueue_head(&common->fsg_wait);
common->state = <API key>;
return common;
}
void <API key>(struct fsg_common *common, bool sysfs)
{
common->sysfs = sysfs;
}
EXPORT_SYMBOL_GPL(<API key>);
static void <API key>(struct fsg_buffhd *buffhds, unsigned n)
{
if (buffhds) {
struct fsg_buffhd *bh = buffhds;
while (n
kfree(bh->buf);
++bh;
}
kfree(buffhds);
}
}
int <API key>(struct fsg_common *common, unsigned int n)
{
struct fsg_buffhd *bh, *buffhds;
int i, rc;
size_t extra_buf_alloc = 0;
if (common->gadget)
extra_buf_alloc = common->gadget->extra_buf_alloc;
rc = <API key>(n);
if (rc != 0)
return rc;
buffhds = kcalloc(n, sizeof(*buffhds), GFP_KERNEL);
if (!buffhds)
return -ENOMEM;
/* Data buffers cyclic list */
bh = buffhds;
i = n;
goto buffhds_first_it;
do {
bh->next = bh + 1;
++bh;
buffhds_first_it:
bh->buf = kmalloc(FSG_BUFLEN + extra_buf_alloc,
GFP_KERNEL);
if (unlikely(!bh->buf))
goto error_release;
} while (--i);
bh->next = buffhds;
<API key>(common->buffhds, common->fsg_num_buffers);
common->fsg_num_buffers = n;
common->buffhds = buffhds;
return 0;
error_release:
/*
* "buf"s pointed to by heads after n - i are NULL
* so releasing them won't hurt
*/
<API key>(buffhds, n);
return -ENOMEM;
}
EXPORT_SYMBOL_GPL(<API key>);
static inline void <API key>(struct fsg_lun *lun)
{
device_remove_file(&lun->dev, &dev_attr_nofua);
/*
* device_remove_file() =>
*
* here the attr (e.g. dev_attr_ro) is only used to be passed to:
*
* sysfs_remove_file() =>
*
* here e.g. both dev_attr_ro_cdrom and dev_attr_ro are in
* the same namespace and
* from here only attr->name is passed to:
*
* <API key>()
*
* attr->name is the same for dev_attr_ro_cdrom and
* dev_attr_ro
* attr->name is the same for dev_attr_file and
* <API key>
*
* so we don't differentiate between removing e.g. dev_attr_ro_cdrom
* and dev_attr_ro
*/
device_remove_file(&lun->dev, &dev_attr_ro);
device_remove_file(&lun->dev, &dev_attr_file);
device_remove_file(&lun->dev, &dev_attr_perf);
}
void <API key>(struct fsg_lun *lun, bool sysfs)
{
if (sysfs) {
<API key>(lun);
device_unregister(&lun->dev);
}
fsg_lun_close(lun);
kfree(lun);
}
EXPORT_SYMBOL_GPL(<API key>);
static void <API key>(struct fsg_common *common, int n)
{
int i;
for (i = 0; i < n; ++i)
if (common->luns[i]) {
<API key>(common->luns[i], common->sysfs);
common->luns[i] = NULL;
}
}
EXPORT_SYMBOL_GPL(<API key>);
void <API key>(struct fsg_common *common)
{
<API key>(common, common->nluns);
}
void <API key>(struct fsg_common *common)
{
unsigned long flags;
<API key>(common);
spin_lock_irqsave(&common->lock, flags);
kfree(common->luns);
common->luns = NULL;
common->nluns = 0;
<API key>(&common->lock, flags);
}
EXPORT_SYMBOL_GPL(<API key>);
int <API key>(struct fsg_common *common, int nluns)
{
struct fsg_lun **curlun;
/* Find out how many LUNs there should be */
if (nluns < 1 || nluns > FSG_MAX_LUNS) {
pr_err("invalid number of LUNs: %u\n", nluns);
return -EINVAL;
}
curlun = kcalloc(nluns, sizeof(*curlun), GFP_KERNEL);
if (unlikely(!curlun))
return -ENOMEM;
if (common->luns)
<API key>(common);
common->luns = curlun;
common->nluns = nluns;
pr_info("Number of LUNs=%d\n", common->nluns);
return 0;
}
EXPORT_SYMBOL_GPL(<API key>);
void fsg_common_set_ops(struct fsg_common *common,
const struct fsg_operations *ops)
{
common->ops = ops;
}
EXPORT_SYMBOL_GPL(fsg_common_set_ops);
void <API key>(struct fsg_common *common)
{
<API key>(common->buffhds, common->fsg_num_buffers);
common->buffhds = NULL;
}
EXPORT_SYMBOL_GPL(<API key>);
int fsg_common_set_cdev(struct fsg_common *common,
struct usb_composite_dev *cdev, bool can_stall)
{
struct usb_string *us;
common->gadget = cdev->gadget;
common->ep0 = cdev->gadget->ep0;
common->ep0req = cdev->req;
common->cdev = cdev;
us = usb_gstrings_attach(cdev, fsg_strings_array,
ARRAY_SIZE(fsg_strings));
if (IS_ERR(us))
return PTR_ERR(us);
fsg_intf_desc.iInterface = us[<API key>].id;
/*
* Some peripheral controllers are known not to be able to
* halt bulk endpoints correctly. If one of them is present,
* disable stalls.
*/
common->can_stall = can_stall && !(gadget_is_at91(common->gadget));
return 0;
}
EXPORT_SYMBOL_GPL(fsg_common_set_cdev);
static inline int <API key>(struct fsg_common *common,
struct fsg_lun *lun)
{
int rc;
rc = device_register(&lun->dev);
if (rc) {
put_device(&lun->dev);
return rc;
}
rc = device_create_file(&lun->dev,
lun->cdrom
? &dev_attr_ro_cdrom
: &dev_attr_ro);
if (rc)
goto error;
rc = device_create_file(&lun->dev,
lun->removable
? &dev_attr_file
: &<API key>);
if (rc)
goto error;
rc = device_create_file(&lun->dev, &dev_attr_nofua);
if (rc)
goto error;
rc = device_create_file(&lun->dev, &dev_attr_perf);
if (rc)
pr_err("failed to create sysfs entry: %d\n", rc);
return 0;
error:
/* removing nonexistent files is a no-op */
<API key>(lun);
device_unregister(&lun->dev);
return rc;
}
int <API key>(struct fsg_common *common, struct fsg_lun_config *cfg,
unsigned int id, const char *name,
const char **name_pfx)
{
struct fsg_lun *lun;
char *pathbuf, *p;
int rc = -ENOMEM;
if (!common->nluns || !common->luns)
return -ENODEV;
if (common->luns[id])
return -EBUSY;
#ifdef CONFIG_ZTEMT_USB
if (!cfg->filename && !cfg->removable && !cfg->cdrom) {
#else
if (!cfg->filename && !cfg->removable) {
#endif
pr_err("no file given for LUN%d\n", id);
return -EINVAL;
}
lun = kzalloc(sizeof(*lun), GFP_KERNEL);
if (!lun)
return -ENOMEM;
lun->name_pfx = name_pfx;
lun->cdrom = !!cfg->cdrom;
lun->ro = cfg->cdrom || cfg->ro;
lun->initially_ro = lun->ro;
lun->removable = !!cfg->removable;
if (!common->sysfs) {
/* we DON'T own the name!*/
lun->name = name;
} else {
lun->dev.release = fsg_lun_release;
lun->dev.parent = &common->gadget->dev;
dev_set_drvdata(&lun->dev, &common->filesem);
dev_set_name(&lun->dev, "%s", name);
lun->name = dev_name(&lun->dev);
rc = <API key>(common, lun);
if (rc) {
pr_info("failed to register LUN%d: %d\n", id, rc);
goto error_sysfs;
}
}
common->luns[id] = lun;
if (cfg->filename) {
rc = fsg_lun_open(lun, cfg->filename);
if (rc)
goto error_lun;
}
pathbuf = kmalloc(PATH_MAX, GFP_KERNEL);
p = "(no medium)";
if (fsg_lun_is_open(lun)) {
p = "(error)";
if (pathbuf) {
p = d_path(&lun->filp->f_path, pathbuf, PATH_MAX);
if (IS_ERR(p))
p = "(error)";
}
}
pr_info("LUN: %s%s%sfile: %s\n",
lun->removable ? "removable " : "",
lun->ro ? "read only " : "",
lun->cdrom ? "CD-ROM " : "",
p);
kfree(pathbuf);
return 0;
error_lun:
if (common->sysfs) {
<API key>(lun);
device_unregister(&lun->dev);
}
fsg_lun_close(lun);
common->luns[id] = NULL;
error_sysfs:
kfree(lun);
return rc;
}
EXPORT_SYMBOL_GPL(<API key>);
int <API key>(struct fsg_common *common, struct fsg_config *cfg)
{
char buf[8]; /* enough for 100000000 different numbers, decimal */
int i, rc;
for (i = 0; i < common->nluns; ++i) {
snprintf(buf, sizeof(buf), "lun%d", i);
rc = <API key>(common, &cfg->luns[i], i, buf, NULL);
if (rc)
goto fail;
}
pr_info("Number of LUNs=%d\n", common->nluns);
return 0;
fail:
<API key>(common, i);
return rc;
}
EXPORT_SYMBOL_GPL(<API key>);
void <API key>(struct fsg_common *common, const char *vn,
const char *pn)
{
int i;
/* Prepare inquiryString */
i = <API key>();
snprintf(common->inquiry_string, sizeof(common->inquiry_string),
"%-8s%-16s%04x", vn ?: "Linux",
/* Assume product name dependent on the first LUN */
pn ?: ((*common->luns)->cdrom
? "File-CD Gadget"
: "File-Stor Gadget"),
i);
}
EXPORT_SYMBOL_GPL(<API key>);
int <API key>(struct fsg_common *common)
{
common->state = FSG_STATE_IDLE;
/* Tell the thread to start working */
common->thread_task =
kthread_create(fsg_main_thread, common, "file-storage");
if (IS_ERR(common->thread_task)) {
common->state = <API key>;
return PTR_ERR(common->thread_task);
}
DBG(common, "I/O thread pid: %d\n", task_pid_nr(common->thread_task));
wake_up_process(common->thread_task);
return 0;
}
EXPORT_SYMBOL_GPL(<API key>);
static void fsg_common_release(struct kref *ref)
{
struct fsg_common *common = container_of(ref, struct fsg_common, ref);
/* If the thread isn't already dead, tell it to exit now */
if (common->state != <API key>) {
raise_exception(common, FSG_STATE_EXIT);
wait_for_completion(&common->thread_notifier);
}
if (likely(common->luns)) {
struct fsg_lun **lun_it = common->luns;
unsigned i = common->nluns;
/* In error recovery common->nluns may be zero. */
for (; i; --i, ++lun_it) {
struct fsg_lun *lun = *lun_it;
if (!lun)
continue;
if (common->sysfs)
<API key>(lun);
fsg_lun_close(lun);
if (common->sysfs)
device_unregister(&lun->dev);
kfree(lun);
}
kfree(common->luns);
}
<API key>(common->buffhds, common->fsg_num_buffers);
if (common-><API key>)
kfree(common);
}
int fsg_sysfs_update(struct fsg_common *common, struct device *dev, bool create)
{
int ret = 0, i;
pr_debug("%s(): common->nluns:%d\n", __func__, common->nluns);
if (create) {
for (i = 0; i < common->nluns; i++) {
if (i == 0)
snprintf(common->name[i], 8, "lun");
else
snprintf(common->name[i], 8, "lun%d", i-1);
ret = sysfs_create_link(&dev->kobj,
&common->luns[i]->dev.kobj,
common->name[i]);
if (ret) {
pr_err("%s(): failed creating sysfs:%d %s)\n",
__func__, i, common->name[i]);
goto remove_sysfs;
}
}
} else {
i = common->nluns;
goto remove_sysfs;
}
return 0;
remove_sysfs:
for (; i > 0; i
pr_debug("%s(): delete sysfs for lun(id:%d)(name:%s)\n",
__func__, i, common->name[i-1]);
sysfs_remove_link(&dev->kobj, common->name[i-1]);
}
return ret;
}
EXPORT_SYMBOL(fsg_sysfs_update);
static int fsg_bind(struct usb_configuration *c, struct usb_function *f)
{
struct fsg_dev *fsg = fsg_from_func(f);
struct usb_gadget *gadget = c->cdev->gadget;
int i;
struct usb_ep *ep;
unsigned max_burst;
int ret;
struct fsg_opts *opts;
opts = <API key>(f->fi);
if (!opts->no_configfs) {
ret = fsg_common_set_cdev(fsg->common, c->cdev,
fsg->common->can_stall);
if (ret)
return ret;
#ifdef CONFIG_ZTEMT_USB
<API key>(fsg->common, "nubia", "Android");
#else
<API key>(fsg->common, NULL, NULL);
#endif
ret = <API key>(fsg->common);
if (ret)
return ret;
}
fsg->gadget = gadget;
/* New interface */
i = usb_interface_id(c, f);
if (i < 0)
return i;
fsg_intf_desc.bInterfaceNumber = i;
fsg->interface_number = i;
/* Find all the endpoints we will use */
ep = usb_ep_autoconfig(gadget, &fsg_fs_bulk_in_desc);
if (!ep)
goto autoconf_fail;
ep->driver_data = fsg->common; /* claim the endpoint */
fsg->bulk_in = ep;
ep = usb_ep_autoconfig(gadget, &<API key>);
if (!ep)
goto autoconf_fail;
ep->driver_data = fsg->common; /* claim the endpoint */
fsg->bulk_out = ep;
/* Assume endpoint addresses are the same for both speeds */
fsg_hs_bulk_in_desc.bEndpointAddress =
fsg_fs_bulk_in_desc.bEndpointAddress;
<API key>.bEndpointAddress =
<API key>.bEndpointAddress;
/* Calculate bMaxBurst, we know packet size is 1024 */
max_burst = min_t(unsigned, FSG_BUFLEN / 1024, 15);
fsg_ss_bulk_in_desc.bEndpointAddress =
fsg_fs_bulk_in_desc.bEndpointAddress;
<API key>.bMaxBurst = max_burst;
<API key>.bEndpointAddress =
<API key>.bEndpointAddress;
<API key>.bMaxBurst = max_burst;
ret = <API key>(f, fsg_fs_function, fsg_hs_function,
fsg_ss_function);
if (ret)
goto autoconf_fail;
return 0;
autoconf_fail:
ERROR(fsg, "unable to autoconfigure all endpoints\n");
return -ENOTSUPP;
}
static void fsg_unbind(struct usb_configuration *c, struct usb_function *f)
{
struct fsg_dev *fsg = fsg_from_func(f);
struct fsg_common *common = fsg->common;
DBG(fsg, "unbind\n");
if (fsg->common->fsg == fsg) {
fsg->common->new_fsg = NULL;
raise_exception(fsg->common, <API key>);
/* FIXME: make interruptible or killable somehow? */
wait_event(common->fsg_wait, common->fsg != fsg);
}
<API key>(&fsg->function);
}
static inline struct fsg_lun_opts *to_fsg_lun_opts(struct config_item *item)
{
return container_of(to_config_group(item), struct fsg_lun_opts, group);
}
static inline struct fsg_opts *to_fsg_opts(struct config_item *item)
{
return container_of(to_config_group(item), struct fsg_opts,
func_inst.group);
}
<API key>(fsg_lun_opts);
CONFIGFS_ATTR_OPS(fsg_lun_opts);
static void <API key>(struct config_item *item)
{
struct fsg_lun_opts *lun_opts;
lun_opts = to_fsg_lun_opts(item);
kfree(lun_opts);
}
static struct <API key> fsg_lun_item_ops = {
.release = <API key>,
.show_attribute = <API key>,
.store_attribute = <API key>,
};
static ssize_t <API key>(struct fsg_lun_opts *opts, char *page)
{
struct fsg_opts *fsg_opts;
fsg_opts = to_fsg_opts(opts->group.cg_item.ci_parent);
return fsg_show_file(opts->lun, &fsg_opts->common->filesem, page);
}
static ssize_t <API key>(struct fsg_lun_opts *opts,
const char *page, size_t len)
{
struct fsg_opts *fsg_opts;
fsg_opts = to_fsg_opts(opts->group.cg_item.ci_parent);
return fsg_store_file(opts->lun, &fsg_opts->common->filesem, page, len);
}
static struct <API key> fsg_lun_opts_file =
__CONFIGFS_ATTR(file, S_IRUGO | S_IWUSR, <API key>,
<API key>);
static ssize_t <API key>(struct fsg_lun_opts *opts, char *page)
{
return fsg_show_ro(opts->lun, page);
}
static ssize_t <API key>(struct fsg_lun_opts *opts,
const char *page, size_t len)
{
struct fsg_opts *fsg_opts;
fsg_opts = to_fsg_opts(opts->group.cg_item.ci_parent);
return fsg_store_ro(opts->lun, &fsg_opts->common->filesem, page, len);
}
static struct <API key> fsg_lun_opts_ro =
__CONFIGFS_ATTR(ro, S_IRUGO | S_IWUSR, <API key>,
<API key>);
static ssize_t <API key>(struct fsg_lun_opts *opts,
char *page)
{
return fsg_show_removable(opts->lun, page);
}
static ssize_t <API key>(struct fsg_lun_opts *opts,
const char *page, size_t len)
{
return fsg_store_removable(opts->lun, page, len);
}
static struct <API key> <API key> =
__CONFIGFS_ATTR(removable, S_IRUGO | S_IWUSR,
<API key>,
<API key>);
static ssize_t <API key>(struct fsg_lun_opts *opts, char *page)
{
return fsg_show_cdrom(opts->lun, page);
}
static ssize_t <API key>(struct fsg_lun_opts *opts,
const char *page, size_t len)
{
struct fsg_opts *fsg_opts;
fsg_opts = to_fsg_opts(opts->group.cg_item.ci_parent);
return fsg_store_cdrom(opts->lun, &fsg_opts->common->filesem, page,
len);
}
static struct <API key> fsg_lun_opts_cdrom =
__CONFIGFS_ATTR(cdrom, S_IRUGO | S_IWUSR, <API key>,
<API key>);
static ssize_t <API key>(struct fsg_lun_opts *opts, char *page)
{
return fsg_show_nofua(opts->lun, page);
}
static ssize_t <API key>(struct fsg_lun_opts *opts,
const char *page, size_t len)
{
return fsg_store_nofua(opts->lun, page, len);
}
static struct <API key> fsg_lun_opts_nofua =
__CONFIGFS_ATTR(nofua, S_IRUGO | S_IWUSR, <API key>,
<API key>);
static struct configfs_attribute *fsg_lun_attrs[] = {
&fsg_lun_opts_file.attr,
&fsg_lun_opts_ro.attr,
&<API key>.attr,
&fsg_lun_opts_cdrom.attr,
&fsg_lun_opts_nofua.attr,
NULL,
};
static struct config_item_type fsg_lun_type = {
.ct_item_ops = &fsg_lun_item_ops,
.ct_attrs = fsg_lun_attrs,
.ct_owner = THIS_MODULE,
};
static struct config_group *fsg_lun_make(struct config_group *group,
const char *name)
{
struct fsg_lun_opts *opts;
struct fsg_opts *fsg_opts;
struct fsg_lun_config config;
char *num_str;
u8 num;
int ret;
num_str = strchr(name, '.');
if (!num_str) {
pr_err("Unable to locate . in LUN.NUMBER\n");
return ERR_PTR(-EINVAL);
}
num_str++;
ret = kstrtou8(num_str, 0, &num);
if (ret)
return ERR_PTR(ret);
fsg_opts = to_fsg_opts(&group->cg_item);
if (num >= FSG_MAX_LUNS)
return ERR_PTR(-ERANGE);
mutex_lock(&fsg_opts->lock);
if (fsg_opts->refcnt || fsg_opts->common->luns[num]) {
ret = -EBUSY;
goto out;
}
opts = kzalloc(sizeof(*opts), GFP_KERNEL);
if (!opts) {
ret = -ENOMEM;
goto out;
}
memset(&config, 0, sizeof(config));
config.removable = true;
ret = <API key>(fsg_opts->common, &config, num, name,
(const char **)&group->cg_item.ci_name);
if (ret) {
kfree(opts);
goto out;
}
opts->lun = fsg_opts->common->luns[num];
opts->lun_id = num;
mutex_unlock(&fsg_opts->lock);
<API key>(&opts->group, name, &fsg_lun_type);
return &opts->group;
out:
mutex_unlock(&fsg_opts->lock);
return ERR_PTR(ret);
}
static void fsg_lun_drop(struct config_group *group, struct config_item *item)
{
struct fsg_lun_opts *lun_opts;
struct fsg_opts *fsg_opts;
lun_opts = to_fsg_lun_opts(item);
fsg_opts = to_fsg_opts(&group->cg_item);
mutex_lock(&fsg_opts->lock);
if (fsg_opts->refcnt) {
struct config_item *gadget;
gadget = group->cg_item.ci_parent->ci_parent;
<API key>(gadget);
}
<API key>(lun_opts->lun, fsg_opts->common->sysfs);
fsg_opts->common->luns[lun_opts->lun_id] = NULL;
lun_opts->lun_id = 0;
mutex_unlock(&fsg_opts->lock);
config_item_put(item);
}
<API key>(fsg_opts);
CONFIGFS_ATTR_OPS(fsg_opts);
static void fsg_attr_release(struct config_item *item)
{
struct fsg_opts *opts = to_fsg_opts(item);
<API key>(&opts->func_inst);
}
static struct <API key> fsg_item_ops = {
.release = fsg_attr_release,
.show_attribute = fsg_opts_attr_show,
.store_attribute = fsg_opts_attr_store,
};
static ssize_t fsg_opts_stall_show(struct fsg_opts *opts, char *page)
{
int result;
mutex_lock(&opts->lock);
result = sprintf(page, "%d", opts->common->can_stall);
mutex_unlock(&opts->lock);
return result;
}
static ssize_t <API key>(struct fsg_opts *opts, const char *page,
size_t len)
{
int ret;
bool stall;
mutex_lock(&opts->lock);
if (opts->refcnt) {
mutex_unlock(&opts->lock);
return -EBUSY;
}
ret = strtobool(page, &stall);
if (!ret) {
opts->common->can_stall = stall;
ret = len;
}
mutex_unlock(&opts->lock);
return ret;
}
static struct fsg_opts_attribute fsg_opts_stall =
__CONFIGFS_ATTR(stall, S_IRUGO | S_IWUSR, fsg_opts_stall_show,
<API key>);
#ifdef <API key>
static ssize_t <API key>(struct fsg_opts *opts, char *page)
{
int result;
mutex_lock(&opts->lock);
result = sprintf(page, "%d", opts->common->fsg_num_buffers);
mutex_unlock(&opts->lock);
return result;
}
static ssize_t <API key>(struct fsg_opts *opts,
const char *page, size_t len)
{
int ret;
u8 num;
mutex_lock(&opts->lock);
if (opts->refcnt) {
ret = -EBUSY;
goto end;
}
ret = kstrtou8(page, 0, &num);
if (ret)
goto end;
ret = <API key>(num);
if (ret)
goto end;
<API key>(opts->common, num);
ret = len;
end:
mutex_unlock(&opts->lock);
return ret;
}
static struct fsg_opts_attribute <API key> =
__CONFIGFS_ATTR(num_buffers, S_IRUGO | S_IWUSR,
<API key>,
<API key>);
#endif
static struct configfs_attribute *fsg_attrs[] = {
&fsg_opts_stall.attr,
#ifdef <API key>
&<API key>.attr,
#endif
NULL,
};
static struct <API key> fsg_group_ops = {
.make_group = fsg_lun_make,
.drop_item = fsg_lun_drop,
};
static struct config_item_type fsg_func_type = {
.ct_item_ops = &fsg_item_ops,
.ct_group_ops = &fsg_group_ops,
.ct_attrs = fsg_attrs,
.ct_owner = THIS_MODULE,
};
static void fsg_free_inst(struct <API key> *fi)
{
struct fsg_opts *opts;
opts = <API key>(fi);
fsg_common_put(opts->common);
kfree(opts);
}
static struct <API key> *fsg_alloc_inst(void)
{
struct fsg_opts *opts;
struct fsg_lun_config config;
int rc;
opts = kzalloc(sizeof(*opts), GFP_KERNEL);
if (!opts)
return ERR_PTR(-ENOMEM);
mutex_init(&opts->lock);
opts->func_inst.free_func_inst = fsg_free_inst;
opts->common = fsg_common_setup(opts->common);
if (IS_ERR(opts->common)) {
rc = PTR_ERR(opts->common);
goto release_opts;
}
rc = <API key>(opts->common, FSG_MAX_LUNS);
if (rc)
goto release_opts;
rc = <API key>(opts->common,
<API key>);
if (rc)
goto release_luns;
pr_info(FSG_DRIVER_DESC ", version: " FSG_DRIVER_VERSION "\n");
memset(&config, 0, sizeof(config));
config.removable = true;
rc = <API key>(opts->common, &config, 0, "lun.0",
(const char **)&opts->func_inst.group.cg_item.ci_name);
opts->lun0.lun = opts->common->luns[0];
opts->lun0.lun_id = 0;
<API key>(&opts->lun0.group, "lun.0", &fsg_lun_type);
opts->default_groups[0] = &opts->lun0.group;
opts->func_inst.group.default_groups = opts->default_groups;
<API key>(&opts->func_inst.group, "", &fsg_func_type);
return &opts->func_inst;
release_luns:
kfree(opts->common->luns);
release_opts:
kfree(opts);
return ERR_PTR(rc);
}
static void fsg_free(struct usb_function *f)
{
struct fsg_dev *fsg;
struct fsg_opts *opts;
fsg = container_of(f, struct fsg_dev, function);
opts = container_of(f->fi, struct fsg_opts, func_inst);
mutex_lock(&opts->lock);
opts->refcnt
mutex_unlock(&opts->lock);
kfree(fsg);
}
static struct usb_function *fsg_alloc(struct <API key> *fi)
{
struct fsg_opts *opts = <API key>(fi);
struct fsg_common *common = opts->common;
struct fsg_dev *fsg;
fsg = kzalloc(sizeof(*fsg), GFP_KERNEL);
if (unlikely(!fsg))
return ERR_PTR(-ENOMEM);
mutex_lock(&opts->lock);
opts->refcnt++;
mutex_unlock(&opts->lock);
fsg->function.name = FSG_DRIVER_DESC;
fsg->function.bind = fsg_bind;
fsg->function.unbind = fsg_unbind;
fsg->function.setup = fsg_setup;
fsg->function.set_alt = fsg_set_alt;
fsg->function.disable = fsg_disable;
fsg->function.free_func = fsg_free;
fsg->common = common;
setup_timer(&common->vfs_timer, <API key>,
(unsigned long) common);
return &fsg->function;
}
<API key>(mass_storage, fsg_alloc_inst, fsg_alloc);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Michal Nazarewicz");
void <API key>(struct fsg_config *cfg,
const struct <API key> *params,
unsigned int fsg_num_buffers)
{
struct fsg_lun_config *lun;
unsigned i;
/* Configure LUNs */
cfg->nluns =
min(params->luns ?: (params->file_count ?: 1u),
(unsigned)FSG_MAX_LUNS);
for (i = 0, lun = cfg->luns; i < cfg->nluns; ++i, ++lun) {
lun->ro = !!params->ro[i];
lun->cdrom = !!params->cdrom[i];
lun->removable = !!params->removable[i];
lun->filename =
params->file_count > i && params->file[i][0]
? params->file[i]
: NULL;
}
/* Let MSF use defaults */
cfg->vendor_name = NULL;
cfg->product_name = NULL;
cfg->ops = NULL;
cfg->private_data = NULL;
/* Finalise */
cfg->can_stall = params->stall;
cfg->fsg_num_buffers = fsg_num_buffers;
}
EXPORT_SYMBOL_GPL(<API key>);
|
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
#include "hwmp-protocol.h"
#include "hwmp-protocol-mac.h"
#include "hwmp-tag.h"
#include "hwmp-rtable.h"
#include "ns3/log.h"
#include "ns3/simulator.h"
#include "ns3/packet.h"
#include "ns3/mesh-point-device.h"
#include "ns3/wifi-net-device.h"
#include "ns3/mesh-point-device.h"
#include "ns3/<API key>.h"
#include "ns3/<API key>.h"
#include "airtime-metric.h"
#include "ie-dot11s-preq.h"
#include "ie-dot11s-prep.h"
#include "ns3/<API key>.h"
#include "ie-dot11s-perr.h"
#include "ns3/arp-l3-protocol.h"
#include "ns3/ipv4-l3-protocol.h"
#include "ns3/udp-l4-protocol.h"
#include "ns3/tcp-l4-protocol.h"
#include "ns3/arp-header.h"
#include "ns3/ipv4-header.h"
#include "ns3/tcp-header.h"
#include "ns3/udp-header.h"
#include "ns3/rhoSigma-tag.h"
#include "ns3/llc-snap-header.h"
#include "ns3/wifi-mac-trailer.h"
#include "dot11s-mac-header.h"
<API key> ("HwmpProtocol");
namespace ns3 {
namespace dot11s {
<API key> (HwmpProtocol)
;
//#include <config.h>
#include <math.h>
#include <float.h>
TypeId
HwmpProtocol::GetTypeId ()
{
static TypeId tid = TypeId ("ns3::dot11s::HwmpProtocol")
.SetParent<<API key>> ()
.AddConstructor<HwmpProtocol> ()
.AddAttribute ( "RandomStart",
"Random delay at first proactive PREQ",
TimeValue (Seconds (0.1)),
MakeTimeAccessor (
&HwmpProtocol::m_randomStart),
MakeTimeChecker ()
)
.AddAttribute ( "MaxQueueSize",
"Maximum number of packets we can store when resolving route",
UintegerValue (255),
<API key> (
&HwmpProtocol::m_maxQueueSize),
MakeUintegerChecker<uint16_t> (1)
)
.AddAttribute ( "<API key>",
"Maximum number of retries before we suppose the destination to be unreachable",
UintegerValue (3),
<API key> (
&HwmpProtocol::<API key>),
MakeUintegerChecker<uint8_t> (1)
)
.AddAttribute ( "<API key>",
"Time we suppose the packet to go from one edge of the network to another",
TimeValue (MicroSeconds (1024*100)),
MakeTimeAccessor (
&HwmpProtocol::<API key>),
MakeTimeChecker ()
)
.AddAttribute ( "<API key>",
"Minimal interval between to successive PREQs",
TimeValue (MicroSeconds (1024*100)),
MakeTimeAccessor (
&HwmpProtocol::<API key>),
MakeTimeChecker ()
)
.AddAttribute ( "<API key>",
"Minimal interval between to successive PREQs",
TimeValue (MicroSeconds (1024*100)),
MakeTimeAccessor (&HwmpProtocol::<API key>),
MakeTimeChecker ()
)
.AddAttribute ( "<API key>",
"Lifetime of poractive routing information",
TimeValue (MicroSeconds (1024*5000)),
MakeTimeAccessor (
&HwmpProtocol::<API key>),
MakeTimeChecker ()
)
.AddAttribute ( "<API key>",
"Lifetime of reactive routing information",
TimeValue (MicroSeconds (1024*5000)),
MakeTimeAccessor (
&HwmpProtocol::<API key>),
MakeTimeChecker ()
)
.AddAttribute ( "<API key>",
"Interval between two successive proactive PREQs",
TimeValue (MicroSeconds (1024*2000)),
MakeTimeAccessor (
&HwmpProtocol::<API key>),
MakeTimeChecker ()
)
.AddAttribute ( "<API key>",
"Lifetime of poractive routing information",
TimeValue (MicroSeconds (1024*5000)),
MakeTimeAccessor (
&HwmpProtocol::<API key>),
MakeTimeChecker ()
)
.AddAttribute ( "MaxTtl",
"Initial value of Time To Live field",
UintegerValue (32),
<API key> (
&HwmpProtocol::m_maxTtl),
MakeUintegerChecker<uint8_t> (2)
)
.AddAttribute ( "<API key>",
"Maximum number of PERR receivers, when we send a PERR as a chain of unicasts",
UintegerValue (32),
<API key> (
&HwmpProtocol::<API key>),
MakeUintegerChecker<uint8_t> (1)
)
.AddAttribute ( "<API key>",
"Maximum number of PREQ receivers, when we send a PREQ as a chain of unicasts",
UintegerValue (1),
<API key> (
&HwmpProtocol::<API key>),
MakeUintegerChecker<uint8_t> (1)
)
.AddAttribute ( "<API key>",
"Maximum number ofbroadcast receivers, when we send a broadcast as a chain of unicasts",
UintegerValue (1),
<API key> (
&HwmpProtocol::<API key>),
MakeUintegerChecker<uint8_t> (1)
)
.AddAttribute ( "DoFlag",
"Destination only HWMP flag",
BooleanValue (true),
MakeBooleanAccessor (
&HwmpProtocol::m_doFlag),
MakeBooleanChecker ()
)
.AddAttribute ( "RfFlag",
"Reply and forward flag",
BooleanValue (false),
MakeBooleanAccessor (
&HwmpProtocol::m_rfFlag),
MakeBooleanChecker ()
)
.AddTraceSource ( "RouteDiscoveryTime",
"The time of route discovery procedure",
<API key> (
&HwmpProtocol::<API key>)
)
//by hadi
.AddAttribute ( "VBMetricMargin",
"VBMetricMargin",
UintegerValue (2),
<API key> (
&HwmpProtocol::m_VBMetricMargin),
MakeUintegerChecker<uint32_t> (1)
)
.AddAttribute ( "Gppm",
"G Packets Per Minutes",
UintegerValue (3600),
<API key> (
&HwmpProtocol::m_Gppm),
MakeUintegerChecker<uint32_t> (1)
)
.AddTraceSource ( "<API key>",
"",
<API key> (
&HwmpProtocol::<API key>)
)
.AddTraceSource ( "<API key>",
"",
<API key> (
&HwmpProtocol::<API key>)
)
.AddTraceSource( "CbrCnnStateChanged",
"",
<API key>(
&HwmpProtocol::<API key>))
.AddTraceSource( "<API key>",
"",
<API key>(
&HwmpProtocol::<API key>))
;
return tid;
}
HwmpProtocol::HwmpProtocol () :
m_dataSeqno (1),
m_hwmpSeqno (1),
m_preqId (0),
m_rtable (CreateObject<HwmpRtable> ()),
m_randomStart (Seconds (0.1)),
m_maxQueueSize (255),
<API key> (3),
<API key> (MicroSeconds (1024*100)),
<API key> (MicroSeconds (1024*100)),
<API key> (MicroSeconds (1024*100)),
<API key> (MicroSeconds (1024*5000)),
<API key> (MicroSeconds (1024*5000)),
<API key> (MicroSeconds (1024*2000)),
<API key> (MicroSeconds (1024*5000)),
m_isRoot (false),
m_maxTtl (32),
<API key> (32),
<API key> (1),
<API key> (1),
m_doFlag (true),
m_rfFlag (false),
m_VBMetricMargin(2)
{
<API key> ();
m_noDataPacketYet=true;
m_energyPerByte=0;
m_coefficient = CreateObject<<API key>> ();
}
HwmpProtocol::~HwmpProtocol ()
{
<API key> ();
}
void
HwmpProtocol::DoInitialize ()
{
m_coefficient->SetAttribute ("Max", DoubleValue (m_randomStart.GetSeconds ()));
if (m_isRoot)
{
SetRoot ();
}
Simulator::Schedule(Seconds(0.5),&HwmpProtocol::<API key>,this);//hadi eo94
m_interfaces.begin ()->second-><API key> (MakeCallback(&HwmpProtocol::EnergyChange,this));
m_interfaces.begin ()->second-><API key> (MakeCallback(&HwmpProtocol::GammaChange,this));
m_rtable->setSystemB (m_interfaces.begin ()->second->GetEres ());
m_rtable->setBPrim (m_rtable->systemB ());
m_rtable->setSystemBMax (m_interfaces.begin ()->second->GetBatteryCapacity ());
m_rtable->setBPrimMax (m_rtable->systemBMax ());
m_rtable->setAssignedGamma (0);
m_rtable->setGppm (m_Gppm);
GammaChange (m_rtable->systemGamma (),<API key>);
m_rtable->UpdateToken ();
}
void
HwmpProtocol::DoDispose ()
{
<API key> ();
for (std::map<Mac48Address, PreqEvent>::iterator i = m_preqTimeouts.begin (); i != m_preqTimeouts.end (); i++)
{
i->second.preqTimeout.Cancel ();
}
<API key>.Cancel ();
m_preqTimeouts.clear ();
m_lastDataSeqno.clear ();
<API key>.clear ();
for (std::vector<CnnBasedPreqEvent>::iterator cbpei = <API key>.begin (); cbpei != <API key>.end (); cbpei++)
{
cbpei->preqTimeout.Cancel();
}
<API key>.clear();
for(std::vector<DelayedPrepStruct>::iterator dpsi=m_delayedPrepStruct.begin ();dpsi!=m_delayedPrepStruct.end ();dpsi++)
{
dpsi->prepTimeout.Cancel ();
}
m_delayedPrepStruct.clear ();
m_interfaces.clear ();
m_rqueue.clear ();
m_rtable = 0;
m_mp = 0;
}
bool
HwmpProtocol::RequestRoute (
uint32_t sourceIface,
const Mac48Address source,
const Mac48Address destination,
Ptr<const Packet> constPacket,
uint16_t protocolType, //ethrnet 'Protocol' field
<API key>::RouteReplyCallback routeReply
)
{
Ptr <Packet> packet = constPacket->Copy ();
HwmpTag tag;
if (sourceIface == GetMeshPoint ()->GetIfIndex ())
{
// packet from level 3
if (packet->PeekPacketTag (tag))
{
NS_FATAL_ERROR ("HWMP tag has come with a packet from upper layer. This must not occur...");
}
//Filling TAG:
if (destination == Mac48Address::GetBroadcast ())
{
tag.SetSeqno (m_dataSeqno++);
}
tag.SetTtl (m_maxTtl);
}
else
{
if (!packet->RemovePacketTag (tag))
{
NS_FATAL_ERROR ("HWMP tag is supposed to be here at this point.");
}
tag.DecrementTtl ();
if (tag.GetTtl () == 0)
{
m_stats.droppedTtl++;
return false;
}
}
if (destination == Mac48Address::GetBroadcast ())
{
m_stats.txBroadcast++;
m_stats.txBytes += packet->GetSize ();
//channel IDs where we have already sent broadcast:
std::vector<uint16_t> channels;
for (HwmpProtocolMacMap::const_iterator plugin = m_interfaces.begin (); plugin != m_interfaces.end (); plugin++)
{
bool shouldSend = true;
for (std::vector<uint16_t>::const_iterator chan = channels.begin (); chan != channels.end (); chan++)
{
if ((*chan) == plugin->second->GetChannelId ())
{
shouldSend = false;
}
}
if (!shouldSend)
{
continue;
}
channels.push_back (plugin->second->GetChannelId ());
std::vector<Mac48Address> receivers = <API key> (plugin->first);
for (std::vector<Mac48Address>::const_iterator i = receivers.begin (); i != receivers.end (); i++)
{
Ptr<Packet> packetCopy = packet->Copy ();
// 64-bit Intel valgrind complains about tag.SetAddress (*i). It
// likes this just fine.
Mac48Address address = *i;
tag.SetAddress (address);
packetCopy->AddPacketTag (tag);
routeReply (true, packetCopy, source, destination, protocolType, plugin->first);
}
}
}
else
{
return ForwardUnicast (sourceIface, source, destination, packet, protocolType, routeReply, tag.GetTtl ());
}
return true;
}
bool
HwmpProtocol::RemoveRoutingStuff (uint32_t fromIface, const Mac48Address source,
const Mac48Address destination, Ptr<Packet> packet, uint16_t& protocolType)
{
HwmpTag tag;
if (!packet->RemovePacketTag (tag))
{
NS_FATAL_ERROR ("HWMP tag must exist when packet received from the network");
}
return true;
}
bool
HwmpProtocol::ForwardUnicast (uint32_t sourceIface, const Mac48Address source, const Mac48Address destination,
Ptr<Packet> packet, uint16_t protocolType, RouteReplyCallback routeReply, uint32_t ttl)
{
RhoSigmaTag rsTag;
packet->RemovePacketTag (rsTag);
Ptr<Packet> pCopy=packet->Copy();
uint8_t cnnType;//1:mac only, 2:ip only , 3:ip port
Ipv4Address srcIpv4Addr;
Ipv4Address dstIpv4Addr;
uint16_t srcPort;
uint16_t dstPort;
if(protocolType==ArpL3Protocol::PROT_NUMBER)
{
ArpHeader arpHdr;
pCopy->RemoveHeader(arpHdr);
srcIpv4Addr = arpHdr.<API key>();
dstIpv4Addr = arpHdr.<API key>();
cnnType=HwmpRtable::CNN_TYPE_IP_ONLY;
// NS_LOG_HADI(m_address << " ARP packet have seen");
NS_ASSERT(true);
}
else if(protocolType==Ipv4L3Protocol::PROT_NUMBER)
{
Ipv4Header ipv4Hdr;
pCopy->RemoveHeader(ipv4Hdr);
srcIpv4Addr = ipv4Hdr.GetSource();
dstIpv4Addr = ipv4Hdr.GetDestination();
uint8_t protocol = ipv4Hdr.GetProtocol();
if(protocol==TcpL4Protocol::PROT_NUMBER)
{
TcpHeader tcpHdr;
pCopy->RemoveHeader (tcpHdr);
srcPort=tcpHdr.GetSourcePort ();
dstPort=tcpHdr.GetDestinationPort ();
cnnType=HwmpRtable::CNN_TYPE_PKT_BASED;
}
else if(protocol==UdpL4Protocol::PROT_NUMBER)
{
UdpHeader udpHdr;
pCopy->RemoveHeader(udpHdr);
srcPort=udpHdr.GetSourcePort();
dstPort=udpHdr.GetDestinationPort();
cnnType=HwmpRtable::CNN_TYPE_IP_PORT;
// NS_LOG_HADI(m_address << " UDP packet have seen " << source << "->" << destination << " " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort);
}
else
{
cnnType=HwmpRtable::CNN_TYPE_IP_ONLY;
// NS_LOG_HADI(m_address << " non TCP or UDP packet have seen");
NS_ASSERT(true);
}
}
else
{
cnnType=HwmpRtable::CNN_TYPE_MAC_ONLY;
// NS_LOG_HADI(m_address << " non IP packet have seen");
NS_ASSERT(true);
}
if((source==GetAddress())&&(cnnType==HwmpRtable::CNN_TYPE_IP_PORT)){
NS_LOG_ROUTING("hwmp <API key> " << (int)packet->GetUid() << " " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort << " " << (int)rsTag.GetRho () << " " << (int)rsTag.GetSigma () << " " << rsTag.GetStopTime ());
<API key>();
}
NS_ASSERT (destination != Mac48Address::GetBroadcast ());
NS_ASSERT(cnnType==HwmpRtable::CNN_TYPE_IP_PORT);
CbrConnection connection;
connection.destination=destination;
connection.source=source;
connection.cnnType=cnnType;
connection.dstIpv4Addr=dstIpv4Addr;
connection.srcIpv4Addr=srcIpv4Addr;
connection.dstPort=dstPort;
connection.srcPort=srcPort;
if(cnnType==HwmpRtable::CNN_TYPE_IP_PORT){
<API key>::iterator nrccvi=std::find(<API key>.begin(),<API key>.end(),connection);
if(nrccvi!=<API key>.end()){
if(source==GetAddress()){
NS_LOG_ROUTING("hwmp cnnRejectedDrop " << (int)packet->GetUid() << " " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort);
}
return false;
}
}
HwmpRtable::<API key> cnnBasedResult = m_rtable-><API key>(destination,source,cnnType,srcIpv4Addr,dstIpv4Addr,srcPort,dstPort);
NS_LOG_DEBUG ("Requested src = "<<source<<", dst = "<<destination<<", I am "<<GetAddress ()<<", RA = "<<cnnBasedResult.retransmitter);
HwmpTag tag;
tag.SetAddress (cnnBasedResult.retransmitter);
tag.SetTtl (ttl);
//seqno and metric is not used;
packet->AddPacketTag (tag);
if (cnnBasedResult.retransmitter != Mac48Address::GetBroadcast ())
{
if(source==GetAddress())
{
NS_LOG_ROUTING("tx4mSource " << (int)packet->GetUid());
NS_LOG_CAC("tx4mSource " << srcIpv4Addr << ":" << srcPort << "=>" << dstIpv4Addr << ":" << dstPort << " " << (int)packet->GetUid());
<API key>();
<API key> (destination,source,cnnType,srcIpv4Addr,dstIpv4Addr,srcPort,dstPort);
}
else
{
NS_LOG_CAC("<API key> " << srcIpv4Addr << ":" << srcPort << "=>" << dstIpv4Addr << ":" << dstPort << " " << (int)packet->GetUid());
CbrRouteExtend(destination,source,cnnType,srcIpv4Addr,dstIpv4Addr,srcPort,dstPort);
}
//reply immediately:
//routeReply (true, packet, source, destination, protocolType, cnnBasedResult.ifIndex);
NS_LOG_TB("queuing packet in TBVB queue for send " << (int)packet->GetUid ());
m_rtable->QueueCnnBasedPacket (destination,source,cnnType,srcIpv4Addr,dstIpv4Addr,srcPort,dstPort,packet,protocolType,cnnBasedResult.ifIndex,routeReply);
m_stats.txUnicast++;
m_stats.txBytes += packet->GetSize ();
return true;
}
if (sourceIface != GetMeshPoint ()->GetIfIndex ())
{
//Start path error procedure:
NS_LOG_DEBUG ("Must Send PERR");
m_stats.totalDropped++;
return false;
}
//Request a destination:
if (<API key> (rsTag, destination, source, cnnType, srcIpv4Addr, dstIpv4Addr, srcPort, dstPort))
{
NS_LOG_ROUTING("sendingPathRequest " << source << " " << destination);
uint32_t originator_seqno = GetNextHwmpSeqno ();
uint32_t dst_seqno = 0;
m_stats.initiatedPreq++;
for (HwmpProtocolMacMap::const_iterator i = m_interfaces.begin (); i != m_interfaces.end (); i++)
{
if(m_routingType==2)
i->second->RequestDestination (destination, originator_seqno, dst_seqno, cnnType, srcIpv4Addr, dstIpv4Addr, srcPort, dstPort,rsTag.GetRho (), rsTag.GetSigma (), rsTag.GetStopTime (), rsTag.delayBound (), rsTag.maxPktSize (), 0x7fffffff,0x7fffffff,0x7fffffff);
else
i->second->RequestDestination (destination, originator_seqno, dst_seqno, cnnType, srcIpv4Addr, dstIpv4Addr, srcPort, dstPort,rsTag.GetRho (), rsTag.GetSigma (), rsTag.GetStopTime (),rsTag.delayBound (), rsTag.maxPktSize (), 0,0,0);
}
}
QueuedPacket pkt;
pkt.pkt = packet;
pkt.dst = destination;
pkt.src = source;
pkt.protocol = protocolType;
pkt.reply = routeReply;
pkt.inInterface = sourceIface;
pkt.cnnType=cnnType;
pkt.srcIpv4Addr=srcIpv4Addr;
pkt.dstIpv4Addr=dstIpv4Addr;
pkt.srcPort=srcPort;
pkt.dstPort=dstPort;
if (QueuePacket (pkt))
{
if((source==GetAddress ())&&(cnnType==HwmpRtable::CNN_TYPE_IP_PORT))
<API key>(packet);
m_stats.totalQueued++;
return true;
}
else
{
m_stats.totalDropped++;
return false;
}
}
void
HwmpProtocol::ReceivePreq (IePreq preq, Mac48Address from, uint32_t interface, Mac48Address fromMp, uint32_t metric)
{
preq.IncrementMetric (metric);
NS_LOG_ROUTING("receivePreq " << from << " " << (int)preq.GetGammaPrim () << " " << (int)preq.GetBPrim () << " " << (int)preq.GetTotalE () << " " << (int)preq.GetMetric ());
//acceptance cretirea:
// bool duplicatePreq=false;
//bool freshInfo (true);
for(std::vector<<API key>>::iterator i=<API key>.begin();i!=<API key>.end();i++)
{
if(
(i->originatorAddress==preq.<API key>()) &&
(i->cnnType==preq.GetCnnType()) &&
(i->srcIpv4Addr==preq.GetSrcIpv4Addr()) &&
(i->srcPort==preq.GetSrcPort()) &&
(i->dstIpv4Addr==preq.GetDstIpv4Addr()) &&
(i->dstPort==preq.GetDstPort())
)
{
// duplicatePreq=true;
NS_LOG_ROUTING("duplicatePreq " << (int)i->originatorSeqNumber << " " << (int)preq.<API key> ());
if ((int32_t)(i->originatorSeqNumber - preq.<API key> ()) > 0)
{
return;
}
if (i->originatorSeqNumber == preq.<API key> ())
{
//freshInfo = false;
if((m_routingType==1)||(m_routingType==2))
{
NS_LOG_ROUTING("checking prev " << i->bPrim << " " << i->gammaPrim << " " << i->totalE << " " << preq.GetBPrim () << " " << preq.GetGammaPrim () << " " << (int)preq.GetTotalE () << " " << (int)m_VBMetricMargin);
if((i->totalE+m_VBMetricMargin >= preq.GetTotalE ())&&(i->totalE <= preq.GetTotalE ()+m_VBMetricMargin))
{
if((i->metric+m_VBMetricMargin*10 >= preq.GetMetric ())&&(i->metric <= preq.GetMetric ()+m_VBMetricMargin*10))
{
if(m_routingType==1)
{
if(i->bPrim<=preq.GetBPrim ())
{
NS_LOG_ROUTING("b1 rejected " << (int)i->bPrim << " " << (int)i->gammaPrim << " " << (int)preq.GetBPrim () << " " << (int)preq.GetGammaPrim ());
return;
}
}
else
{
if(i->bPrim>=preq.GetBPrim ())
{
NS_LOG_ROUTING("b2 rejected " << (int)i->bPrim << " " << (int)i->gammaPrim << " " << (int)preq.GetBPrim () << " " << (int)preq.GetGammaPrim ());
return;
}
}
}
else if (i->metric <= preq.GetMetric ())
{
NS_LOG_ROUTING("metric rejected " << (int)i->metric << " " << (int)preq.GetMetric ());
return;
}
}
else
if(m_routingType==1)
{
if(i->totalE<=preq.GetTotalE ())
{
NS_LOG_ROUTING("totalE1 rejected " << (int)i->bPrim << " " << (int)i->gammaPrim << " " << (int)preq.GetBPrim () << " " << (int)preq.GetGammaPrim ());
return;
}
}
else
{
if(i->totalE>=preq.GetTotalE ())
{
NS_LOG_ROUTING("totalE2 rejected " << (int)i->bPrim << " " << (int)i->gammaPrim << " " << (int)preq.GetBPrim () << " " << (int)preq.GetGammaPrim ());
return;
}
}
/*NS_LOG_ROUTING("checking prev " << (int)i->metric << " " << (int)preq.GetMetric () << " " << (int)m_VBMetricMargin);
if ((i->metric+m_VBMetricMargin >= preq.GetMetric ())&&(i->metric <= preq.GetMetric ()+m_VBMetricMargin))
{
// check energy metric
NS_LOG_ROUTING("in margin with one prev preq " << (int)i->metric << " " << (int)preq.GetMetric () << " " << (int)m_VBMetricMargin);
if((i->bPrim+i->gammaPrim*(preq.GetStopTime ()-Simulator::Now ()).GetSeconds ())>=(preq.GetBPrim ()+preq.GetGammaPrim ()*(preq.GetStopTime ()-Simulator::Now ()).GetSeconds ()))
{
NS_LOG_ROUTING("bgamma rejected " << (int)i->bPrim << " " << (int)i->gammaPrim << " " << (int)preq.GetBPrim () << " " << (int)preq.GetGammaPrim ());
return;
}
}
else if (i->metric <= preq.GetMetric ())
{
NS_LOG_ROUTING("metric rejected " << (int)i->metric << " " << (int)preq.GetMetric ());
return;
}*/
}
else
{
if (i->metric <= preq.GetMetric ())
{
NS_LOG_ROUTING("metric rejected " << (int)i->metric << " " << (int)preq.GetMetric ());
return;
}
}
}
<API key>.erase (i);
break;
}
}
<API key> newDb;
newDb.originatorAddress=preq.<API key>();
newDb.originatorSeqNumber=preq.<API key>();
newDb.metric=preq.GetMetric();
newDb.cnnType=preq.GetCnnType();
newDb.srcIpv4Addr=preq.GetSrcIpv4Addr();
newDb.dstIpv4Addr=preq.GetDstIpv4Addr();
newDb.srcPort=preq.GetSrcPort();
newDb.dstPort=preq.GetDstPort();
newDb.gammaPrim=preq.GetGammaPrim ();
newDb.bPrim=preq.GetBPrim ();
newDb.totalE=preq.GetTotalE ();
<API key>.push_back(newDb);
std::vector<Ptr<<API key>> > destinations = preq.GetDestinationList ();
//Add reverse path to originator:
m_rtable-><API key> (preq.<API key>(),from,interface,preq.GetCnnType(),preq.GetSrcIpv4Addr(),preq.GetDstIpv4Addr(),preq.GetSrcPort(),preq.GetDstPort(),Seconds(1),preq.<API key>());
//Add reactive path to originator:
for (std::vector<Ptr<<API key>> >::const_iterator i = destinations.begin (); i != destinations.end (); i++)
{
NS_LOG_ROUTING("receivePReq " << preq.<API key>() << " " << from << " " << (*i)-><API key> ());
std::vector<Ptr<<API key>> > preqDestinations = preq.GetDestinationList ();
Mac48Address preqDstMac;
if(preqDestinations.size ()==1){
std::vector<Ptr<<API key>> >::const_iterator preqDstMacIt =preqDestinations.begin ();
preqDstMac=(*preqDstMacIt)-><API key>();
}else{
preqDstMac=GetAddress ();
}
if ((*i)-><API key> () == GetAddress ())
{
// if(!duplicatePreq)
{
if(m_doCAC)
{
// calculate total needed energy for entire connection lifetime and needed energy for bursts.
double totalEnergyNeeded = (m_rtable-><API key>+m_rtable-><API key>)*(preq.GetStopTime ()-Simulator::Now ()).GetSeconds ()*(preq.GetRho ()/60)*m_rtable->m_energyAlpha;
double burstEnergyNeeded = (m_rtable-><API key>+m_rtable-><API key>)*preq.GetSigma ()*m_rtable->m_energyAlpha;
double <API key> = m_rtable->bPrim ()+ m_rtable->gammaPrim ()*(preq.GetStopTime ()-Simulator::Now ()).GetSeconds ();
NS_LOG_ROUTING("<API key> " << m_rtable-><API key> << " " << m_rtable-><API key> << " " << (int)preq.GetRho () << " " << (int)preq.GetSigma () << " " << preq.GetStopTime () << " ; " << totalEnergyNeeded << " " << burstEnergyNeeded << " " << <API key> << " " << m_rtable->bPrim ());
if( ( ( m_rtable->bPrim ()< burstEnergyNeeded ) || ( <API key> < totalEnergyNeeded ) ) || (!m_interfaces.begin()->second-><API key>(preq.<API key> (),preqDstMac,preq.GetHopCount (),from,preq.GetRho ()) ) )// CAC check
{
NS_LOG_ROUTING("cac rejected the connection " << totalEnergyNeeded << " " << burstEnergyNeeded << " " << <API key> << " " << m_rtable->bPrim ());
return;
}
}
else
{
if(m_rtable->bPrim ()<=0)
{
NS_LOG_ROUTING("bPrim()<=0_1 rejected the connection " << m_rtable->bPrim ());
return;
}
}
}
NS_LOG_ROUTING("schedule2sendPrep");
Schedule2sendPrep (
GetAddress (),
preq.<API key> (),
preq.GetMetric(),
preq.GetCnnType(),
preq.GetSrcIpv4Addr(),
preq.GetDstIpv4Addr(),
preq.GetSrcPort(),
preq.GetDstPort(),
preq.GetRho (),
preq.GetSigma (),
preq.GetStopTime (),
preq.GetDelayBound (),
preq.GetMaxPktSize (),
preq.<API key> (),
GetNextHwmpSeqno (),
preq.GetLifetime (),
interface
);
//NS_ASSERT (m_rtable->LookupReactive (preq.<API key> ()).retransmitter != Mac48Address::GetBroadcast ());
preq.<API key> ((*i)-><API key> ());
continue;
}
else
{
// if(!duplicatePreq)
{
if(m_doCAC)
{
// calculate total needed energy for entire connection lifetime and needed energy for bursts.
double totalEnergyNeeded = 2 * (m_rtable-><API key>+m_rtable-><API key>)*(preq.GetStopTime ()-Simulator::Now ()).GetSeconds ()*(preq.GetRho ()/60)*m_rtable->m_energyAlpha;
double burstEnergyNeeded = 2 * (m_rtable-><API key>+m_rtable-><API key>)*preq.GetSigma ()*m_rtable->m_energyAlpha;
double <API key> = m_rtable->bPrim ()+ m_rtable->gammaPrim ()*(preq.GetStopTime ()-Simulator::Now ()).GetSeconds ();
NS_LOG_ROUTING("<API key> " << m_rtable-><API key> << " " << m_rtable-><API key> << " " << (int)preq.GetRho () << " " << (int)preq.GetSigma () << " " << preq.GetStopTime () << " ; " << totalEnergyNeeded << " " << burstEnergyNeeded << " " << <API key> << " " << m_rtable->bPrim ());
if( ( ( m_rtable->bPrim ()< burstEnergyNeeded ) || ( <API key> < totalEnergyNeeded ) ) || (!m_interfaces.begin()->second-><API key>(preq.<API key> (),preqDstMac,preq.GetHopCount (),from,preq.GetRho ()) ) )// CAC check
{
NS_LOG_ROUTING("cac rejected the connection " << totalEnergyNeeded << " " << burstEnergyNeeded << " " << <API key> << " " << m_rtable->bPrim ());
return;
}
}
else
{
if(m_rtable->bPrim ()<=0)
{
NS_LOG_ROUTING("bPrim()<=0_2 rejected the connection " << m_rtable->bPrim ());
return;
}
}
}
if(m_routingType==1)
preq.UpdateVBMetricSum (m_rtable->gammaPrim (),m_rtable->bPrim ());
else if(m_routingType==2)
preq.UpdateVBMetricMin (m_rtable->gammaPrim (),m_rtable->bPrim ());
}
}
NS_LOG_DEBUG ("I am " << GetAddress () << "Accepted preq from address" << from << ", preq:" << preq);
//check if must retransmit:
if (preq.GetDestCount () == 0)
{
return;
}
//Forward PREQ to all interfaces:
NS_LOG_DEBUG ("I am " << GetAddress () << "retransmitting PREQ:" << preq);
NS_LOG_ROUTING("forwardPreq");
for (HwmpProtocolMacMap::const_iterator i = m_interfaces.begin (); i != m_interfaces.end (); i++)
{
i->second->SendPreq (preq);
}
}
void
HwmpProtocol::Schedule2sendPrep(
Mac48Address src,
Mac48Address dst,
uint32_t initMetric,
uint8_t cnnType,
Ipv4Address srcIpv4Addr,
Ipv4Address dstIpv4Addr,
uint16_t srcPort,
uint16_t dstPort,
uint16_t rho,
uint16_t sigma,
Time stopTime,
Time delayBound,
uint16_t maxPktSize,
uint32_t originatorDsn,
uint32_t destinationSN,
uint32_t lifetime,
uint32_t interface)
{
for(std::vector<DelayedPrepStruct>::iterator dpsi=m_delayedPrepStruct.begin ();dpsi!=m_delayedPrepStruct.end ();dpsi++)
{
if(
(dpsi->destination==dst) &&
(dpsi->source==src) &&
(dpsi->cnnType==cnnType) &&
(dpsi->srcIpv4Addr==srcIpv4Addr) &&
(dpsi->dstIpv4Addr==dstIpv4Addr) &&
(dpsi->srcPort==srcPort) &&
(dpsi->dstPort==dstPort)
)
{
NS_LOG_ROUTING("scheduledBefore");
return;
}
}
DelayedPrepStruct dps;
dps.destination=dst;
dps.source=src;
dps.cnnType=cnnType;
dps.srcIpv4Addr=srcIpv4Addr;
dps.dstIpv4Addr=dstIpv4Addr;
dps.srcPort=srcPort;
dps.dstPort=dstPort;
dps.rho=rho;
dps.sigma=sigma;
dps.stopTime=stopTime;
dps.delayBound=delayBound;
dps.maxPktSize=maxPktSize;
dps.initMetric=initMetric;
dps.originatorDsn=originatorDsn;
dps.destinationSN=destinationSN;
dps.lifetime=lifetime;
dps.interface=interface;
dps.whenScheduled=Simulator::Now();
dps.prepTimeout=Simulator::Schedule(Seconds (0.1),&HwmpProtocol::SendDelayedPrep,this,dps);
NS_LOG_ROUTING("scheduled for " << "1" << " seconds");
m_delayedPrepStruct.push_back (dps);
}
void
HwmpProtocol::SendDelayedPrep(DelayedPrepStruct dps)
{
NS_LOG_ROUTING("trying to send prep to " << dps.destination);
HwmpRtable::<API key> result=m_rtable-><API key>(dps.destination,dps.cnnType,dps.srcIpv4Addr,dps.dstIpv4Addr,dps.srcPort,dps.dstPort);
if (result.retransmitter == Mac48Address::GetBroadcast ())
{
NS_LOG_ROUTING("cant find reverse path");
return;
}
//this is only for assigning a VB for this connection
if(!m_rtable-><API key> (
dps.destination,
GetAddress (),
dps.source,
result.retransmitter,
dps.interface,
dps.cnnType,
dps.srcIpv4Addr,
dps.dstIpv4Addr,
dps.srcPort,
dps.dstPort,
dps.rho,
dps.sigma,
dps.stopTime,
dps.delayBound,
dps.maxPktSize,
Seconds (dps.lifetime),
dps.originatorDsn,
false,
m_doCAC))
{
return;
}
SendPrep (
GetAddress (),
dps.destination,
result.retransmitter,
dps.initMetric,
dps.cnnType,
dps.srcIpv4Addr,
dps.dstIpv4Addr,
dps.srcPort,
dps.dstPort,
dps.rho,
dps.sigma,
dps.stopTime,
dps.delayBound,
dps.maxPktSize,
dps.originatorDsn,
dps.destinationSN,
dps.lifetime,
dps.interface
);
NS_LOG_ROUTING("prep sent and <API key>");
//std::vector<DelayedPrepStruct>::iterator it=std::find(m_delayedPrepStruct.begin (),m_delayedPrepStruct.end (),dps);
//if(it!=m_delayedPrepStruct.end ())
// m_delayedPrepStruct.erase (it); // we dont erase the entry from the vector cause of preventing to send prep twice
}
void
HwmpProtocol::ReceivePrep (IePrep prep, Mac48Address from, uint32_t interface, Mac48Address fromMp, uint32_t metric)
{
NS_LOG_UNCOND( Simulator::Now ().GetSeconds () << " " << (int)Simulator::GetContext () << " prep received " << prep.GetSrcIpv4Addr() << ":" << (int)prep.GetSrcPort() << "=>" << prep.GetDstIpv4Addr() << ":" << (int)prep.GetDstPort());
NS_LOG_ROUTING("prep received");
if(prep.<API key> () == GetAddress ()){
NS_LOG_ROUTING("prep received for me");
CbrConnection connection;
connection.cnnType=prep.GetCnnType ();
connection.dstIpv4Addr=prep.GetDstIpv4Addr ();
connection.srcIpv4Addr=prep.GetSrcIpv4Addr ();
connection.dstPort=prep.GetDstPort ();
connection.srcPort=prep.GetSrcPort ();
<API key>::iterator nrccvi=std::find(<API key>.begin(),<API key>.end(),connection);
if(nrccvi!=<API key>.end()){
NS_LOG_ROUTING("sourceCnnHasDropped " << prep.GetSrcIpv4Addr() << ":" << (int)prep.GetSrcPort() << "=>" << prep.GetDstIpv4Addr() << ":" << (int)prep.GetDstPort() << " " << from);
return;
}
}
prep.IncrementMetric (metric);
//acceptance cretirea:
bool freshInfo (true);
std::vector<<API key>>::iterator dbit;
for(std::vector<<API key>>::iterator i=<API key>.begin();i!=<API key>.end();i++)
{
if(
(i->originatorAddress==prep.<API key>()) &&
(i->cnnType==prep.GetCnnType()) &&
(i->srcIpv4Addr==prep.GetSrcIpv4Addr()) &&
(i->srcPort==prep.GetSrcPort()) &&
(i->dstIpv4Addr==prep.GetDstIpv4Addr()) &&
(i->dstPort==prep.GetDstPort())
)
{
if ((int32_t)(i-><API key> - prep.<API key>()) > 0)
{
/*BarghiTest 1392/08/02 add for get result start*/
//commented for hadireports std::cout << "t:" << Simulator::Now() << " ,Im " << m_address << " returning because of older preq" << std::endl;
/*BarghiTest 1392/08/02 add for get result end*/
NS_LOG_ROUTING("hwmp droppedCPREP seqnum " << prep.GetSrcIpv4Addr() << ":" << (int)prep.GetSrcPort() << "=>" << prep.GetDstIpv4Addr() << ":" << (int)prep.GetDstPort() << " " << from);
return;
}
dbit=i;
freshInfo=false;
break;
}
}
if(freshInfo)
{
<API key> newDb;
newDb.originatorAddress=prep.<API key>();
newDb.originatorSeqNumber=prep.<API key>();
newDb.destinationAddress=prep.<API key>();
newDb.<API key>=prep.<API key>();
newDb.metric=prep.GetMetric();
newDb.cnnType=prep.GetCnnType();
newDb.srcIpv4Addr=prep.GetSrcIpv4Addr();
newDb.dstIpv4Addr=prep.GetDstIpv4Addr();
newDb.srcPort=prep.GetSrcPort();
newDb.dstPort=prep.GetDstPort();
<API key>.push_back(newDb);
if (prep.<API key> () == GetAddress ())
{
if(!m_rtable-><API key> (
prep.<API key> (),
from,
GetAddress (),
GetAddress (),
interface,
prep.GetCnnType (),
prep.GetSrcIpv4Addr (),
prep.GetDstIpv4Addr (),
prep.GetSrcPort (),
prep.GetDstPort (),
prep.GetRho (),
prep.GetSigma (),
prep.GetStopTime (),
prep.GetDelayBound (),
prep.GetMaxPktSize (),
Seconds (10000),
prep.<API key> (),
false,
m_doCAC))
{
NS_LOG_ROUTING("cac rejected at <API key> the connection ");
CbrConnection connection;
connection.destination=prep.<API key> ();
connection.source=GetAddress ();
connection.cnnType=prep.GetCnnType ();
connection.dstIpv4Addr=prep.GetDstIpv4Addr ();
connection.srcIpv4Addr=prep.GetSrcIpv4Addr ();
connection.dstPort=prep.GetDstPort ();
connection.srcPort=prep.GetSrcPort ();
<API key>.push_back (connection);
return;
}
m_rtable->AddPrecursor (prep.<API key> (), interface, from,
MicroSeconds (prep.GetLifetime () * 1024));
/*if (result.retransmitter != Mac48Address::GetBroadcast ())
{
m_rtable->AddPrecursor (prep.<API key> (), interface, result.retransmitter,
result.lifetime);
}*/
//<API key> (prep.<API key> ());
NS_LOG_ROUTING("hwmp routing pathResolved and <API key> " << prep.<API key> ()<< " " << prep.GetSrcIpv4Addr() << ":" << (int)prep.GetSrcPort() << "=>" << prep.GetDstIpv4Addr() << ":" << (int)prep.GetDstPort() << " " << from);
<API key>(prep.<API key> (),GetAddress (),prep.GetCnnType (),prep.GetSrcIpv4Addr (),prep.GetDstIpv4Addr (),prep.GetSrcPort (),prep.GetDstPort ());
<API key>(prep.GetSrcIpv4Addr(),prep.GetDstIpv4Addr(),prep.GetSrcPort(),prep.GetDstPort(),true);
<API key>(prep.<API key>(),GetAddress (),prep.GetCnnType(),prep.GetSrcIpv4Addr(),prep.GetDstIpv4Addr(),prep.GetSrcPort(),prep.GetDstPort(),GetAddress(),from);
NS_LOG_DEBUG ("I am "<<GetAddress ()<<", resolved "<<prep.<API key> ());
return;
}
}else
{
NS_LOG_ROUTING("duplicate prep not allowed!");
NS_ASSERT(false);
}
//update routing info
//Now add a path to destination and add precursor to source
NS_LOG_DEBUG ("I am " << GetAddress () << ", received prep from " << prep.<API key> () << ", receiver was:" << from);
HwmpRtable::<API key> result=m_rtable-><API key>(prep.<API key>(),prep.GetCnnType(),prep.GetSrcIpv4Addr(),prep.GetDstIpv4Addr(),prep.GetSrcPort(),prep.GetDstPort());
if (result.retransmitter == Mac48Address::GetBroadcast ())
{
NS_LOG_ROUTING("cant find reverse path 2");
return;
}
if(!m_rtable-><API key> ( prep.<API key> (),
from,
prep.<API key> (),
result.retransmitter,
interface,
prep.GetCnnType (),
prep.GetSrcIpv4Addr (),
prep.GetDstIpv4Addr (),
prep.GetSrcPort (),
prep.GetDstPort (),
prep.GetRho (),
prep.GetSigma (),
prep.GetStopTime (),
prep.GetDelayBound (),
prep.GetMaxPktSize (),
Seconds (10000),
prep.<API key> (),
true,
m_doCAC))
{
NS_LOG_ROUTING("cnnRejectedAtPrep " << prep.GetSrcIpv4Addr() << ":" << (int)prep.GetSrcPort() << "=>" << prep.GetDstIpv4Addr() << ":" << (int)prep.GetDstPort());
return;
}
<API key>(prep.<API key>(),prep.<API key>(),prep.GetCnnType(),prep.GetSrcIpv4Addr(),prep.GetDstIpv4Addr(),prep.GetSrcPort(),prep.GetDstPort(),result.retransmitter,from);
//Forward PREP
NS_LOG_ROUTING("hwmp routing pathSaved and <API key> and SendPrep " << prep.<API key> () << " " << result.retransmitter << " " << prep.GetSrcIpv4Addr() << ":" << (int)prep.GetSrcPort() << "=>" << prep.GetDstIpv4Addr() << ":" << (int)prep.GetDstPort() << " " << from << " " << result.retransmitter);
HwmpProtocolMacMap::const_iterator prep_sender = m_interfaces.find (result.ifIndex);
NS_ASSERT (prep_sender != m_interfaces.end ());
prep_sender->second->SendPrep (prep, result.retransmitter);
}
void
HwmpProtocol::<API key>(
Mac48Address destination,
Mac48Address source,
uint8_t cnnType,
Ipv4Address srcIpv4Addr,
Ipv4Address dstIpv4Addr,
uint16_t srcPort,
uint16_t dstPort,
Mac48Address prevHop,
Mac48Address nextHop
){
NS_LOG_ROUTING("hwmp inserting cnn into cnnsvector at source " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort << " n " << nextHop << " p " << prevHop);
CbrConnection connection;
connection.destination=destination;
connection.source=source;
connection.cnnType=cnnType;
connection.dstIpv4Addr=dstIpv4Addr;
connection.srcIpv4Addr=srcIpv4Addr;
connection.dstPort=dstPort;
connection.srcPort=srcPort;
connection.prevMac=prevHop;
connection.nextMac=nextHop;
connection.whenExpires=Simulator::Now()+MilliSeconds(<API key>);
<API key>::iterator ccvi=std::find(<API key>.begin(),<API key>.end(),connection);
if(ccvi==<API key>.end()){
NS_LOG_ROUTING("hwmp new, inserted at source " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort << " n " << nextHop << " p " << prevHop);
<API key>.push_back(connection);
}else{
NS_LOG_ROUTING("hwmp exist, expiration extended at source " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort << " n " << nextHop << " p " << prevHop);
ccvi->whenExpires=Simulator::Now()+Seconds(<API key>);
}
}
void
HwmpProtocol::<API key>(
Mac48Address destination,
Mac48Address source,
uint8_t cnnType,
Ipv4Address srcIpv4Addr,
Ipv4Address dstIpv4Addr,
uint16_t srcPort,
uint16_t dstPort
){
NS_LOG_ROUTING("hwmp cbr route extend at source " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort);
CbrConnection connection;
connection.destination=destination;
connection.source=source;
connection.cnnType=cnnType;
connection.dstIpv4Addr=dstIpv4Addr;
connection.srcIpv4Addr=srcIpv4Addr;
connection.dstPort=dstPort;
connection.srcPort=srcPort;
<API key>::iterator ccvi=std::find(<API key>.begin(),<API key>.end(),connection);
if(ccvi!=<API key>.end()){
NS_LOG_ROUTING("hwmp cbr route really found and extended at source " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort << " n " << ccvi->nextMac << " p " << ccvi->prevMac);
ccvi->whenExpires=Simulator::Now()+MilliSeconds(<API key>);
}else{
NS_LOG_ROUTING("hwmp cbr route not found and not extended at source " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort);
}
}
void
HwmpProtocol::<API key>(
Mac48Address destination,
Mac48Address source,
uint8_t cnnType,
Ipv4Address srcIpv4Addr,
Ipv4Address dstIpv4Addr,
uint16_t srcPort,
uint16_t dstPort,
Mac48Address prevHop,
Mac48Address nextHop
){
NS_LOG_ROUTING("hwmp inserting cnn into cnnsvector " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort << " n " << nextHop << " p " << prevHop);
CbrConnection connection;
connection.destination=destination;
connection.source=source;
connection.cnnType=cnnType;
connection.dstIpv4Addr=dstIpv4Addr;
connection.srcIpv4Addr=srcIpv4Addr;
connection.dstPort=dstPort;
connection.srcPort=srcPort;
connection.prevMac=prevHop;
connection.nextMac=nextHop;
connection.whenExpires=Simulator::Now()+Seconds(<API key>);
//connection.routeExpireEvent=Simulator::Schedule(Seconds(<API key>),&HwmpProtocol::CbrRouteExpire,this,connection);
<API key>::iterator ccvi=std::find(m_cbrConnections.begin(),m_cbrConnections.end(),connection);
if(ccvi==m_cbrConnections.end()){
NS_LOG_ROUTING("hwmp new, inserted " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort << " n " << nextHop << " p " << prevHop);
m_cbrConnections.push_back(connection);
}else{
NS_LOG_ROUTING("hwmp exist, expiration extended " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort << " n " << nextHop << " p " << prevHop);
ccvi->whenExpires=Simulator::Now()+Seconds(<API key>);
ccvi->nextMac=nextHop;
ccvi->prevMac=prevHop;
//m_cbrConnections.erase(ccvi);
//m_cbrConnections.push_back(connection);
//ccvi->routeExpireEvent.Cancel();
//ccvi->routeExpireEvent=Simulator::Schedule(Seconds(<API key>),&HwmpProtocol::CbrRouteExpire,this,connection);
}
}
void
HwmpProtocol::CbrRouteExtend(
Mac48Address destination,
Mac48Address source,
uint8_t cnnType,
Ipv4Address srcIpv4Addr,
Ipv4Address dstIpv4Addr,
uint16_t srcPort,
uint16_t dstPort
){
NS_LOG_ROUTING("hwmp cbr route extend " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort);
CbrConnection connection;
connection.destination=destination;
connection.source=source;
connection.cnnType=cnnType;
connection.dstIpv4Addr=dstIpv4Addr;
connection.srcIpv4Addr=srcIpv4Addr;
connection.dstPort=dstPort;
connection.srcPort=srcPort;
<API key>::iterator ccvi=std::find(m_cbrConnections.begin(),m_cbrConnections.end(),connection);
if(ccvi!=m_cbrConnections.end()){
NS_LOG_ROUTING("hwmp cbr route really found and extended " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort << " n " << ccvi->nextMac << " p " << ccvi->prevMac);
ccvi->whenExpires=Simulator::Now()+Seconds(<API key>);
//ccvi->routeExpireEvent.Cancel();
//ccvi->routeExpireEvent=Simulator::Schedule(Seconds(<API key>),&HwmpProtocol::CbrRouteExpire,this,connection);
}else{
NS_LOG_ROUTING("hwmp cbr route not found and not extended " << srcIpv4Addr << ":" << (int)srcPort << "=>" << dstIpv4Addr << ":" << (int)dstPort);
}
}
void
HwmpProtocol::CbrRouteExpire(CbrConnection cbrCnn){
NS_LOG_ROUTING("hwmp cbr route expired " << cbrCnn.srcIpv4Addr << ":" << (int)cbrCnn.srcPort << "=>" << cbrCnn.dstIpv4Addr << ":" << (int)cbrCnn.dstPort << " n " << cbrCnn.nextMac << " p " << cbrCnn.prevMac);
<API key>::iterator ccvi=std::find(m_cbrConnections.begin(),m_cbrConnections.end(),cbrCnn);
if(ccvi!=m_cbrConnections.end()){
m_cbrConnections.erase(ccvi);
m_rtable-><API key>(cbrCnn.destination,cbrCnn.source,cbrCnn.cnnType,cbrCnn.srcIpv4Addr,cbrCnn.dstIpv4Addr,cbrCnn.srcPort,cbrCnn.dstPort);
NS_LOG_ROUTING("hwmp cbr route deleted " << cbrCnn.srcIpv4Addr << ":" << (int)cbrCnn.srcPort << "=>" << cbrCnn.dstIpv4Addr << ":" << (int)cbrCnn.dstPort << " n " << cbrCnn.nextMac << " p " << cbrCnn.prevMac);
}
}
void
HwmpProtocol::<API key>(){
<API key> tempvector;
bool changed=false;
for(<API key>::iterator ccvi=m_cbrConnections.begin();ccvi!=m_cbrConnections.end();ccvi++){
if(Simulator::Now()<ccvi->whenExpires){
tempvector.push_back(*ccvi);
}else{
changed = true;
m_rtable-><API key>(ccvi->destination,ccvi->source,ccvi->cnnType,ccvi->srcIpv4Addr,ccvi->dstIpv4Addr,ccvi->srcPort,ccvi->dstPort);
NS_LOG_ROUTING("hwmp cbr route expired and deleted " << ccvi->srcIpv4Addr << ":" << (int)ccvi->srcPort << "=>" << ccvi->dstIpv4Addr << ":" << (int)ccvi->dstPort << " n " << ccvi->nextMac << " p " << ccvi->prevMac);
}
}
if(changed){
m_cbrConnections.clear();
m_cbrConnections=tempvector;
NS_LOG_ROUTING("hwmp num connections " << m_cbrConnections.size());
}
tempvector.clear();
for(<API key>::iterator ccvi=<API key>.begin();ccvi!=<API key>.end();ccvi++){
if(Simulator::Now()<ccvi->whenExpires){
tempvector.push_back(*ccvi);
}else{
changed = true;
<API key>(ccvi->srcIpv4Addr,ccvi->dstIpv4Addr,ccvi->srcPort,ccvi->dstPort,false);
}
}
if(changed){
<API key>.clear();
<API key>=tempvector;
}
Simulator::Schedule(MilliSeconds(50),&HwmpProtocol::<API key>,this);
}
void
HwmpProtocol::ReceivePerr (std::vector<FailedDestination> destinations, Mac48Address from, uint32_t interface, Mac48Address fromMp)
{
//Acceptance cretirea:
NS_LOG_DEBUG ("I am "<<GetAddress ()<<", received PERR from "<<from);
std::vector<FailedDestination> retval;
HwmpRtable::LookupResult result;
for (unsigned int i = 0; i < destinations.size (); i++)
{
result = m_rtable-><API key> (destinations[i].destination);
if (!(
(result.retransmitter != from) ||
(result.ifIndex != interface) ||
((int32_t)(result.seqnum - destinations[i].seqnum) > 0)
))
{
retval.push_back (destinations[i]);
}
}
if (retval.size () == 0)
{
return;
}
ForwardPathError (MakePathError (retval));
}
void
HwmpProtocol::SendPrep (Mac48Address src,
Mac48Address dst,
Mac48Address retransmitter,
uint32_t initMetric,
uint8_t cnnType,
Ipv4Address srcIpv4Addr,
Ipv4Address dstIpv4Addr,
uint16_t srcPort,
uint16_t dstPort,
uint16_t rho,
uint16_t sigma,
Time stopTime, Time delayBound, uint16_t maxPktSize,
uint32_t originatorDsn,
uint32_t destinationSN,
uint32_t lifetime,
uint32_t interface)
{
IePrep prep;
prep.SetHopcount (0);
prep.SetTtl (m_maxTtl);
prep.<API key> (dst);
prep.<API key> (destinationSN);
prep.SetLifetime (lifetime);
prep.SetMetric (initMetric);
prep.SetCnnParams(cnnType,srcIpv4Addr,dstIpv4Addr,srcPort,dstPort);
prep.SetRho (rho);
prep.SetSigma (sigma);
prep.SetStopTime (stopTime);
prep.SetDelayBound (delayBound);
prep.SetMaxPktSize (maxPktSize);
prep.<API key> (src);
prep.<API key> (originatorDsn);
HwmpProtocolMacMap::const_iterator prep_sender = m_interfaces.find (interface);
NS_ASSERT (prep_sender != m_interfaces.end ());
prep_sender->second->SendPrep (prep, retransmitter);
m_stats.initiatedPrep++;
}
bool
HwmpProtocol::Install (Ptr<MeshPointDevice> mp)
{
m_mp = mp;
std::vector<Ptr<NetDevice> > interfaces = mp->GetInterfaces ();
for (std::vector<Ptr<NetDevice> >::const_iterator i = interfaces.begin (); i != interfaces.end (); i++)
{
// Checking for compatible net device
Ptr<WifiNetDevice> wifiNetDev = (*i)->GetObject<WifiNetDevice> ();
if (wifiNetDev == 0)
{
return false;
}
Ptr<<API key>> mac = wifiNetDev->GetMac ()->GetObject<<API key>> ();
if (mac == 0)
{
return false;
}
// Installing plugins:
Ptr<HwmpProtocolMac> hwmpMac = Create<HwmpProtocolMac> (wifiNetDev->GetIfIndex (), this);
m_interfaces[wifiNetDev->GetIfIndex ()] = hwmpMac;
mac->InstallPlugin (hwmpMac);
//Installing airtime link metric:
Ptr<<API key>> metric = CreateObject <<API key>> ();
mac-><API key> (MakeCallback (&<API key>::CalculateMetric, metric));
}
mp->SetRoutingProtocol (this);
// Mesh point aggregates all installed protocols
mp->AggregateObject (this);
m_address = Mac48Address::ConvertFrom (mp->GetAddress ()); // address;
return true;
}
void
HwmpProtocol::PeerLinkStatus (Mac48Address meshPointAddress, Mac48Address peerAddress, uint32_t interface, bool status)
{
if (status)
{
return;
}
std::vector<FailedDestination> destinations = m_rtable-><API key> (peerAddress);
InitiatePathError (MakePathError (destinations));
}
void
HwmpProtocol::<API key> (Callback<std::vector<Mac48Address>, uint32_t> cb)
{
<API key> = cb;
}
bool
HwmpProtocol::DropDataFrame (uint32_t seqno, Mac48Address source)
{
if (source == GetAddress ())
{
return true;
}
std::map<Mac48Address, uint32_t,std::less<Mac48Address> >::const_iterator i = m_lastDataSeqno.find (source);
if (i == m_lastDataSeqno.end ())
{
m_lastDataSeqno[source] = seqno;
}
else
{
if ((int32_t)(i->second - seqno) >= 0)
{
return true;
}
m_lastDataSeqno[source] = seqno;
}
return false;
}
HwmpProtocol::PathError
HwmpProtocol::MakePathError (std::vector<FailedDestination> destinations)
{
PathError retval;
//HwmpRtable increments a sequence number as written in 11B.9.7.2
retval.receivers = GetPerrReceivers (destinations);
if (retval.receivers.size () == 0)
{
return retval;
}
m_stats.initiatedPerr++;
for (unsigned int i = 0; i < destinations.size (); i++)
{
retval.destinations.push_back (destinations[i]);
m_rtable->DeleteReactivePath (destinations[i].destination);
}
return retval;
}
void
HwmpProtocol::InitiatePathError (PathError perr)
{
for (HwmpProtocolMacMap::const_iterator i = m_interfaces.begin (); i != m_interfaces.end (); i++)
{
std::vector<Mac48Address> <API key>;
for (unsigned int j = 0; j < perr.receivers.size (); j++)
{
if (i->first == perr.receivers[j].first)
{
<API key>.push_back (perr.receivers[j].second);
}
}
i->second->InitiatePerr (perr.destinations, <API key>);
}
}
void
HwmpProtocol::ForwardPathError (PathError perr)
{
for (HwmpProtocolMacMap::const_iterator i = m_interfaces.begin (); i != m_interfaces.end (); i++)
{
std::vector<Mac48Address> <API key>;
for (unsigned int j = 0; j < perr.receivers.size (); j++)
{
if (i->first == perr.receivers[j].first)
{
<API key>.push_back (perr.receivers[j].second);
}
}
i->second->ForwardPerr (perr.destinations, <API key>);
}
}
std::vector<std::pair<uint32_t, Mac48Address> >
HwmpProtocol::GetPerrReceivers (std::vector<FailedDestination> failedDest)
{
HwmpRtable::PrecursorList retval;
for (unsigned int i = 0; i < failedDest.size (); i++)
{
HwmpRtable::PrecursorList precursors = m_rtable->GetPrecursors (failedDest[i].destination);
m_rtable->DeleteReactivePath (failedDest[i].destination);
m_rtable->DeleteProactivePath (failedDest[i].destination);
for (unsigned int j = 0; j < precursors.size (); j++)
{
retval.push_back (precursors[j]);
}
}
//Check if we have dublicates in retval and precursors:
for (unsigned int i = 0; i < retval.size (); i++)
{
for (unsigned int j = i+1; j < retval.size (); j++)
{
if (retval[i].second == retval[j].second)
{
retval.erase (retval.begin () + j);
}
}
}
return retval;
}
std::vector<Mac48Address>
HwmpProtocol::GetPreqReceivers (uint32_t interface)
{
std::vector<Mac48Address> retval;
if (!<API key>.IsNull ())
{
retval = <API key> (interface);
}
if ((retval.size () >= <API key>) || (retval.size () == 0))
{
retval.clear ();
retval.push_back (Mac48Address::GetBroadcast ());
}
return retval;
}
std::vector<Mac48Address>
HwmpProtocol::<API key> (uint32_t interface)
{
std::vector<Mac48Address> retval;
if (!<API key>.IsNull ())
{
retval = <API key> (interface);
}
if ((retval.size () >= <API key>) || (retval.size () == 0))
{
retval.clear ();
retval.push_back (Mac48Address::GetBroadcast ());
}
return retval;
}
bool
HwmpProtocol::QueuePacket (QueuedPacket packet)
{
if (m_rqueue.size () >= m_maxQueueSize)
{
NS_LOG_CAC("packetDroppedAtHwmp " << (int)packet.pkt->GetUid () << " " << m_rqueue.size ());
return false;
}
m_rqueue.push_back (packet);
return true;
}
HwmpProtocol::QueuedPacket
HwmpProtocol::<API key> (
Mac48Address dst,
Mac48Address src,
uint8_t cnnType,
Ipv4Address srcIpv4Addr,
Ipv4Address dstIpv4Addr,
uint16_t srcPort,
uint16_t dstPort
)
{
QueuedPacket retval;
retval.pkt = 0;
NS_LOG_ROUTING("hwmp <API key> " << (int)m_rqueue.size());
for (std::vector<QueuedPacket>::iterator i = m_rqueue.begin (); i != m_rqueue.end (); i++)
{
if (
((*i).dst == dst) &&
((*i).src == src) &&
((*i).cnnType == cnnType) &&
((*i).srcIpv4Addr == srcIpv4Addr) &&
((*i).dstIpv4Addr == dstIpv4Addr) &&
((*i).srcPort == srcPort) &&
((*i).dstPort == dstPort)
)
{
retval = (*i);
m_rqueue.erase (i);
break;
}
}
//std::cout << Simulator::Now().GetSeconds() << " " << m_address << " SourceQueueSize " << m_rqueue.size() << std::endl;
return retval;
}
HwmpProtocol::QueuedPacket
HwmpProtocol::<API key> (Mac48Address dst)
{
QueuedPacket retval;
retval.pkt = 0;
for (std::vector<QueuedPacket>::iterator i = m_rqueue.begin (); i != m_rqueue.end (); i++)
{
if ((*i).dst == dst)
{
retval = (*i);
m_rqueue.erase (i);
break;
}
}
return retval;
}
HwmpProtocol::QueuedPacket
HwmpProtocol::DequeueFirstPacket ()
{
QueuedPacket retval;
retval.pkt = 0;
if (m_rqueue.size () != 0)
{
retval = m_rqueue[0];
m_rqueue.erase (m_rqueue.begin ());
}
return retval;
}
void
HwmpProtocol::<API key> (Mac48Address dst)
{
std::map<Mac48Address, PreqEvent>::iterator i = m_preqTimeouts.find (dst);
if (i != m_preqTimeouts.end ())
{
<API key> (Simulator::Now () - i->second.whenScheduled);
}
HwmpRtable::LookupResult result = m_rtable->LookupReactive (dst);
NS_ASSERT (result.retransmitter != Mac48Address::GetBroadcast ());
//Send all packets stored for this destination
QueuedPacket packet = <API key> (dst);
while (packet.pkt != 0)
{
if(packet.src==GetAddress()){
NS_LOG_ROUTING("tx4mSource2 " << (int)packet.pkt->GetUid());
}
//set RA tag for retransmitter:
HwmpTag tag;
packet.pkt->RemovePacketTag (tag);
tag.SetAddress (result.retransmitter);
packet.pkt->AddPacketTag (tag);
m_stats.txUnicast++;
m_stats.txBytes += packet.pkt->GetSize ();
packet.reply (true, packet.pkt, packet.src, packet.dst, packet.protocol, result.ifIndex);
packet = <API key> (dst);
}
}
void
HwmpProtocol::<API key> (
Mac48Address dst,
Mac48Address src,
uint8_t cnnType,
Ipv4Address srcIpv4Addr,
Ipv4Address dstIpv4Addr,
uint16_t srcPort,
uint16_t dstPort
)
{
HwmpRtable::<API key> result = m_rtable-><API key>(dst,src,cnnType,srcIpv4Addr,dstIpv4Addr,srcPort,dstPort);
NS_ASSERT (result.retransmitter != Mac48Address::GetBroadcast ());
//Send all packets stored for this destination
QueuedPacket packet = <API key> (dst,src,cnnType,srcIpv4Addr,dstIpv4Addr,srcPort,dstPort);
while (packet.pkt != 0)
{
if((packet.src==GetAddress())&&(cnnType==HwmpRtable::CNN_TYPE_IP_PORT)){
NS_LOG_ROUTING("tx4mSource2 " << (int)packet.pkt->GetUid());
NS_LOG_CAC("tx4mSource2 " << (int)packet.pkt->GetUid());
<API key>();
}
//set RA tag for retransmitter:
HwmpTag tag;
packet.pkt->RemovePacketTag (tag);
tag.SetAddress (result.retransmitter);
packet.pkt->AddPacketTag (tag);
m_stats.txUnicast++;
m_stats.txBytes += packet.pkt->GetSize ();
//packet.reply (true, packet.pkt, packet.src, packet.dst, packet.protocol, result.ifIndex);
// m_rtable->QueueCnnBasedPacket (packet.dst,packet.src,cnnType,srcIpv4Addr,dstIpv4Addr,srcPort,dstPort,packet.pkt,packet.protocol,result.ifIndex,packet.reply);
packet = <API key> (dst,src,cnnType,srcIpv4Addr,dstIpv4Addr,srcPort,dstPort);
}
}
void
HwmpProtocol::<API key> ()
{
//send all packets to root
HwmpRtable::LookupResult result = m_rtable->LookupProactive ();
NS_ASSERT (result.retransmitter != Mac48Address::GetBroadcast ());
QueuedPacket packet = DequeueFirstPacket ();
while (packet.pkt != 0)
{
//set RA tag for retransmitter:
HwmpTag tag;
if (!packet.pkt->RemovePacketTag (tag))
{
NS_FATAL_ERROR ("HWMP tag must be present at this point");
}
tag.SetAddress (result.retransmitter);
packet.pkt->AddPacketTag (tag);
m_stats.txUnicast++;
m_stats.txBytes += packet.pkt->GetSize ();
packet.reply (true, packet.pkt, packet.src, packet.dst, packet.protocol, result.ifIndex);
packet = DequeueFirstPacket ();
}
}
bool
HwmpProtocol::ShouldSendPreq (Mac48Address dst)
{
std::map<Mac48Address, PreqEvent>::const_iterator i = m_preqTimeouts.find (dst);
if (i == m_preqTimeouts.end ())
{
m_preqTimeouts[dst].preqTimeout = Simulator::Schedule (
Time (<API key> * 2),
&HwmpProtocol::RetryPathDiscovery, this, dst, 1);
m_preqTimeouts[dst].whenScheduled = Simulator::Now ();
return true;
}
return false;
}
bool
HwmpProtocol::<API key> (
RhoSigmaTag rsTag,
Mac48Address dst,
Mac48Address src,
uint8_t cnnType,
Ipv4Address srcIpv4Addr,
Ipv4Address dstIpv4Addr,
uint16_t srcPort,
uint16_t dstPort
)
{
for(std::vector<CnnBasedPreqEvent>::iterator cbpei = <API key>.begin (); cbpei != <API key>.end (); cbpei++)
{
if(
(cbpei->destination==dst) &&
(cbpei->source==src) &&
(cbpei->cnnType==cnnType) &&
(cbpei->srcIpv4Addr==srcIpv4Addr) &&
(cbpei->dstIpv4Addr==dstIpv4Addr) &&
(cbpei->srcPort==srcPort) &&
(cbpei->dstPort==dstPort)
)
{
return false;
}
}
if(src==GetAddress ())
{
if(m_doCAC)
{
// calculate total needed energy for entire connection lifetime and needed energy for bursts.
double totalEnergyNeeded = (m_rtable-><API key>+m_rtable-><API key>)*(rsTag.GetStopTime ()-Simulator::Now ()).GetSeconds ()*(rsTag.GetRho ()/60)*m_rtable->m_energyAlpha;
double burstEnergyNeeded = (m_rtable-><API key>+m_rtable-><API key>)*rsTag.GetSigma ()*m_rtable->m_energyAlpha;
double <API key> = m_rtable->bPrim ()+ m_rtable->gammaPrim ()*(rsTag.GetStopTime ()-Simulator::Now ()).GetSeconds ();
NS_LOG_ROUTING("<API key> " << m_rtable-><API key> << " " << m_rtable-><API key> << " " << (int)rsTag.GetRho () << " " << (int)rsTag.GetSigma () << " " << rsTag.GetStopTime () << " ; " << totalEnergyNeeded << " " << burstEnergyNeeded << " " << <API key> << " " << m_rtable->bPrim ());
if( ( ( m_rtable->bPrim () < burstEnergyNeeded ) || ( <API key> < totalEnergyNeeded ) ) || (!m_interfaces.begin ()->second-><API key> (GetAddress (),dst,0,GetAddress (),rsTag.GetRho ())) )// CAC check
{
NS_LOG_ROUTING("cac rejected at source the connection " << totalEnergyNeeded << " " << burstEnergyNeeded << " " << <API key> << " " << m_rtable->bPrim ());
CbrConnection connection;
connection.destination=dst;
connection.source=src;
connection.cnnType=cnnType;
connection.dstIpv4Addr=dstIpv4Addr;
connection.srcIpv4Addr=srcIpv4Addr;
connection.dstPort=dstPort;
connection.srcPort=srcPort;
<API key>.push_back (connection);
return false;
}
}
else
{
if(m_rtable->bPrim ()<=0)
{
NS_LOG_ROUTING("bPrim()<=0 rejected at source the connection " << m_rtable->bPrim ());
CbrConnection connection;
connection.destination=dst;
connection.source=src;
connection.cnnType=cnnType;
connection.dstIpv4Addr=dstIpv4Addr;
connection.srcIpv4Addr=srcIpv4Addr;
connection.dstPort=dstPort;
connection.srcPort=srcPort;
<API key>.push_back (connection);
return false;
}
}
}
CnnBasedPreqEvent cbpe;
cbpe.destination=dst;
cbpe.source=src;
cbpe.cnnType=cnnType;
cbpe.srcIpv4Addr=srcIpv4Addr;
cbpe.dstIpv4Addr=dstIpv4Addr;
cbpe.srcPort=srcPort;
cbpe.dstPort=dstPort;
cbpe.rho=rsTag.GetRho ();
cbpe.sigma=rsTag.GetSigma ();
cbpe.stopTime=rsTag.GetStopTime ();
cbpe.delayBound=rsTag.delayBound ();
cbpe.maxPktSize=rsTag.maxPktSize ();
cbpe.whenScheduled=Simulator::Now();
cbpe.preqTimeout=Simulator::Schedule(
Time (<API key> * 2),
&HwmpProtocol::<API key>,this,cbpe,1);
<API key>.push_back(cbpe);
NS_LOG_ROUTING("need to send preq");
return true;
}
void
HwmpProtocol::RetryPathDiscovery (Mac48Address dst, uint8_t numOfRetry)
{
HwmpRtable::LookupResult result = m_rtable->LookupReactive (dst);
if (result.retransmitter == Mac48Address::GetBroadcast ())
{
result = m_rtable->LookupProactive ();
}
if (result.retransmitter != Mac48Address::GetBroadcast ())
{
std::map<Mac48Address, PreqEvent>::iterator i = m_preqTimeouts.find (dst);
NS_ASSERT (i != m_preqTimeouts.end ());
m_preqTimeouts.erase (i);
return;
}
if (numOfRetry > <API key>)
{
NS_LOG_ROUTING("givingUpPathRequest " << dst);
QueuedPacket packet = <API key> (dst);
//purge queue and delete entry from retryDatabase
while (packet.pkt != 0)
{
m_stats.totalDropped++;
packet.reply (false, packet.pkt, packet.src, packet.dst, packet.protocol, HwmpRtable::MAX_METRIC);
packet = <API key> (dst);
}
std::map<Mac48Address, PreqEvent>::iterator i = m_preqTimeouts.find (dst);
NS_ASSERT (i != m_preqTimeouts.end ());
<API key> (Simulator::Now () - i->second.whenScheduled);
m_preqTimeouts.erase (i);
return;
}
numOfRetry++;
uint32_t originator_seqno = GetNextHwmpSeqno ();
uint32_t dst_seqno = m_rtable-><API key> (dst).seqnum;
NS_LOG_ROUTING("retryPathRequest " << dst);
for (HwmpProtocolMacMap::const_iterator i = m_interfaces.begin (); i != m_interfaces.end (); i++)
{
Ipv4Address tempadd;
if(m_routingType==2)
i->second->RequestDestination (dst, originator_seqno, dst_seqno,HwmpRtable::CNN_TYPE_PKT_BASED,tempadd,tempadd,0,0,0,0,Seconds (0),Seconds (0),0,0x7fffffff,0x7fffffff,0x7fffffff);
else
i->second->RequestDestination (dst, originator_seqno, dst_seqno,HwmpRtable::CNN_TYPE_PKT_BASED,tempadd,tempadd,0,0,0,0,Seconds (0),Seconds (0),0,0,0,0);
}
m_preqTimeouts[dst].preqTimeout = Simulator::Schedule (
Time ((2 * (numOfRetry + 1)) * <API key>),
&HwmpProtocol::RetryPathDiscovery, this, dst, numOfRetry);
}
void
HwmpProtocol::<API key> (
CnnBasedPreqEvent preqEvent,
uint8_t numOfRetry
)
{
HwmpRtable::<API key> result = m_rtable-><API key>(preqEvent.destination,preqEvent.source,preqEvent.cnnType,preqEvent.srcIpv4Addr,preqEvent.dstIpv4Addr,preqEvent.srcPort,preqEvent.dstPort);
if (result.retransmitter != Mac48Address::GetBroadcast ())
{
for(std::vector<CnnBasedPreqEvent>::iterator cbpei = <API key>.begin (); cbpei != <API key>.end (); cbpei++)
{
if(
(cbpei->destination==preqEvent.destination) &&
(cbpei->source==preqEvent.source) &&
(cbpei->cnnType==preqEvent.cnnType) &&
(cbpei->srcIpv4Addr==preqEvent.srcIpv4Addr) &&
(cbpei->dstIpv4Addr==preqEvent.dstIpv4Addr) &&
(cbpei->srcPort==preqEvent.srcPort) &&
(cbpei->dstPort==preqEvent.dstPort)
)
{
<API key>.erase(cbpei);
return;
}
}
NS_ASSERT (false);
return;
}
if (numOfRetry > <API key>)
{
//hadireport reject connection
NS_LOG_ROUTING("hwmp connectionRejected " << preqEvent.destination << " " << preqEvent.srcIpv4Addr << ":" << (int)preqEvent.srcPort << "=>" << preqEvent.dstIpv4Addr << ":" << (int)preqEvent.dstPort);
QueuedPacket packet = <API key> (preqEvent.destination,preqEvent.source,preqEvent.cnnType,preqEvent.srcIpv4Addr,preqEvent.dstIpv4Addr,preqEvent.srcPort,preqEvent.dstPort);
CbrConnection connection;
connection.destination=preqEvent.destination;
connection.source=preqEvent.source;
connection.cnnType=preqEvent.cnnType;
connection.dstIpv4Addr=preqEvent.dstIpv4Addr;
connection.srcIpv4Addr=preqEvent.srcIpv4Addr;
connection.dstPort=preqEvent.dstPort;
connection.srcPort=preqEvent.srcPort;
<API key>::iterator nrccvi=std::find(<API key>.begin(),<API key>.end(),connection);
if(nrccvi==<API key>.end()){
<API key>.push_back(connection);
}
//purge queue and delete entry from retryDatabase
while (packet.pkt != 0)
{
if(packet.src==GetAddress()){
NS_LOG_ROUTING("hwmp noRouteDrop2 " << (int)packet.pkt->GetUid() << " " << preqEvent.srcIpv4Addr << ":" << (int)preqEvent.srcPort << "=>" << preqEvent.dstIpv4Addr << ":" << (int)preqEvent.dstPort);
}
m_stats.totalDropped++;
packet.reply (false, packet.pkt, packet.src, packet.dst, packet.protocol, HwmpRtable::MAX_METRIC);
packet = <API key> (preqEvent.destination,preqEvent.source,preqEvent.cnnType,preqEvent.srcIpv4Addr,preqEvent.dstIpv4Addr,preqEvent.srcPort,preqEvent.dstPort);
}
for(std::vector<CnnBasedPreqEvent>::iterator cbpei = <API key>.begin (); cbpei != <API key>.end (); cbpei++)
{
if(
(cbpei->destination==preqEvent.destination) &&
(cbpei->cnnType==preqEvent.cnnType) &&
(cbpei->srcIpv4Addr==preqEvent.srcIpv4Addr) &&
(cbpei->dstIpv4Addr==preqEvent.dstIpv4Addr) &&
(cbpei->srcPort==preqEvent.srcPort) &&
(cbpei->dstPort==preqEvent.dstPort)
)
{
<API key>.erase(cbpei);
return;
}
}
NS_ASSERT (false);
return;
}
numOfRetry++;
uint32_t originator_seqno = GetNextHwmpSeqno ();
uint32_t dst_seqno = 0;
for (HwmpProtocolMacMap::const_iterator i = m_interfaces.begin (); i != m_interfaces.end (); i++)
{
if(m_routingType==2)
i->second->RequestDestination (preqEvent.destination, originator_seqno, dst_seqno, preqEvent.cnnType, preqEvent.srcIpv4Addr, preqEvent.dstIpv4Addr, preqEvent.srcPort, preqEvent.dstPort,preqEvent.rho,preqEvent.sigma,preqEvent.stopTime,preqEvent.delayBound,preqEvent.maxPktSize, 0x7fffffff,0x7fffffff,0x7fffffff);
else
i->second->RequestDestination (preqEvent.destination, originator_seqno, dst_seqno, preqEvent.cnnType, preqEvent.srcIpv4Addr, preqEvent.dstIpv4Addr, preqEvent.srcPort, preqEvent.dstPort,preqEvent.rho,preqEvent.sigma,preqEvent.stopTime,preqEvent.delayBound,preqEvent.maxPktSize, 0,0,0);
}
for(std::vector<CnnBasedPreqEvent>::iterator cbpei = <API key>.begin (); cbpei != <API key>.end (); cbpei++)
{
if(
(cbpei->destination==preqEvent.destination) &&
(cbpei->cnnType==preqEvent.cnnType) &&
(cbpei->srcIpv4Addr==preqEvent.srcIpv4Addr) &&
(cbpei->dstIpv4Addr==preqEvent.dstIpv4Addr) &&
(cbpei->srcPort==preqEvent.srcPort) &&
(cbpei->dstPort==preqEvent.dstPort)
)
{
cbpei->preqTimeout=Simulator::Schedule(
Time ((2 * (numOfRetry + 1)) * <API key>),
&HwmpProtocol::<API key>,this,(*cbpei),numOfRetry);
cbpei->whenScheduled=Simulator::Now();
return;
}
}
CnnBasedPreqEvent cbpe;
cbpe.destination=preqEvent.destination;
cbpe.cnnType=preqEvent.cnnType;
cbpe.srcIpv4Addr=preqEvent.srcIpv4Addr;
cbpe.dstIpv4Addr=preqEvent.dstIpv4Addr;
cbpe.srcPort=preqEvent.srcPort;
cbpe.dstPort=preqEvent.dstPort;
cbpe.whenScheduled=Simulator::Now();
cbpe.preqTimeout=Simulator::Schedule(
Time ((2 * (numOfRetry + 1)) * <API key>),
&HwmpProtocol::<API key>,this,cbpe,numOfRetry);
<API key>.push_back(cbpe);
}
//Proactive PREQ routines:
void
HwmpProtocol::SetRoot ()
{
Time randomStart = Seconds (m_coefficient->GetValue ());
<API key> = Simulator::Schedule (randomStart, &HwmpProtocol::SendProactivePreq, this);
NS_LOG_DEBUG ("ROOT IS: " << m_address);
m_isRoot = true;
}
void
HwmpProtocol::UnsetRoot ()
{
<API key>.Cancel ();
}
void
HwmpProtocol::SendProactivePreq ()
{
IePreq preq;
//By default: must answer
preq.SetHopcount (0);
preq.SetTTL (m_maxTtl);
preq.SetLifetime (<API key>.GetMicroSeconds () /1024);
//\attention: do not forget to set originator address, sequence
//number and preq ID in HWMP-MAC plugin
preq.<API key> (true, true, Mac48Address::GetBroadcast (), 0);
preq.<API key> (GetAddress ());
preq.SetPreqID (GetNextPreqId ());
preq.<API key> (GetNextHwmpSeqno ());
for (HwmpProtocolMacMap::const_iterator i = m_interfaces.begin (); i != m_interfaces.end (); i++)
{
i->second->SendPreq (preq);
}
<API key> = Simulator::Schedule (<API key>, &HwmpProtocol::SendProactivePreq, this);
}
bool
HwmpProtocol::GetDoFlag ()
{
return m_doFlag;
}
bool
HwmpProtocol::GetRfFlag ()
{
return m_rfFlag;
}
Time
HwmpProtocol::GetPreqMinInterval ()
{
return <API key>;
}
Time
HwmpProtocol::GetPerrMinInterval ()
{
return <API key>;
}
uint8_t
HwmpProtocol::GetMaxTtl ()
{
return m_maxTtl;
}
uint32_t
HwmpProtocol::GetNextPreqId ()
{
m_preqId++;
return m_preqId;
}
uint32_t
HwmpProtocol::GetNextHwmpSeqno ()
{
m_hwmpSeqno++;
return m_hwmpSeqno;
}
uint32_t
HwmpProtocol::<API key> ()
{
return <API key>.GetMicroSeconds () / 1024;
}
uint8_t
HwmpProtocol::<API key> ()
{
return <API key>;
}
Mac48Address
HwmpProtocol::GetAddress ()
{
return m_address;
}
void
HwmpProtocol::EnergyChange (Ptr<Packet> packet,bool isAck, bool incDec, double energy, double remainedEnergy,uint32_t packetSize)
{
uint8_t cnnType;//1:mac only, 2:ip only , 3:ip port
Ipv4Address srcIpv4Addr;
Ipv4Address dstIpv4Addr;
uint16_t srcPort;
uint16_t dstPort;
if(packet!=0)
{
WifiMacHeader wmhdr;
packet->RemoveHeader (wmhdr);
WifiMacTrailer fcs;
packet->RemoveTrailer (fcs);
MeshHeader meshHdr;
packet->RemoveHeader (meshHdr);
LlcSnapHeader llc;
packet->RemoveHeader (llc);
NS_LOG_VB("rxtx packet llc protocol type " << llc.GetType ());
if(llc.GetType ()==Ipv4L3Protocol::PROT_NUMBER)
{
Ipv4Header ipv4Hdr;
packet->RemoveHeader(ipv4Hdr);
srcIpv4Addr = ipv4Hdr.GetSource();
dstIpv4Addr = ipv4Hdr.GetDestination();
uint8_t protocol = ipv4Hdr.GetProtocol();
if(protocol==TcpL4Protocol::PROT_NUMBER)
{
TcpHeader tcpHdr;
packet->RemoveHeader (tcpHdr);
srcPort=tcpHdr.GetSourcePort ();
dstPort=tcpHdr.GetDestinationPort ();
cnnType=HwmpRtable::CNN_TYPE_PKT_BASED;
}
else if(protocol==UdpL4Protocol::PROT_NUMBER)
{
UdpHeader udpHdr;
packet->RemoveHeader(udpHdr);
srcPort=udpHdr.GetSourcePort();
dstPort=udpHdr.GetDestinationPort();
cnnType=HwmpRtable::CNN_TYPE_IP_PORT;
}
else
{
cnnType=HwmpRtable::CNN_TYPE_MAC_ONLY;
}
}
else
{
cnnType=HwmpRtable::CNN_TYPE_MAC_ONLY;
}
}
double systemB=m_rtable->systemB ();
if(incDec)//increased
{
systemB+=energy;
if(systemB>m_rtable->systemBMax ())
systemB=m_rtable->systemBMax ();
if(packet==0)//increased by gamma or energyback
{
if(packetSize==0)//increased by gamma
{
m_rtable-><API key> (energy);
}
else//increased by collision energy back of other packets
{
m_rtable-><API key> (energy);
}
}else//increased by collision energy back
{
m_rtable-><API key> (cnnType,srcIpv4Addr,dstIpv4Addr,srcPort,dstPort,energy,true);
}
}else//decreased
{
systemB-=energy;
if(systemB<0)
systemB=0;
if(packet==0)
{
if(packetSize!=0)//decreased by other types of packets
{
if(m_noDataPacketYet)
{
m_energyPerByte = 0.7 * m_energyPerByte + 0.3 * energy/packetSize;
m_rtable-><API key> (m_energyPerByte*14);
m_rtable-><API key> (m_energyPerByte*260);
//NS_LOG_VB("energyPerAckByte " << m_energyPerByte*14);
//NS_LOG_VB("energyPerDataByte " << m_energyPerByte*260);
}
}
m_rtable-><API key> (energy);
}
else//decreased by data or ack for data packets
{
m_noDataPacketYet=false;
if(isAck )
{
if(energy > m_rtable-><API key> ())
m_rtable-><API key> (energy);
//NS_LOG_VB("energyPerAck " << energy);
}
else if(cnnType==HwmpRtable::CNN_TYPE_IP_PORT)
{
if(energy > m_rtable-><API key> ())
m_rtable-><API key> (energy);
//NS_LOG_VB("energyPerData " << energy);
}
if(cnnType==HwmpRtable::CNN_TYPE_IP_PORT)
{
m_rtable-><API key> (cnnType,srcIpv4Addr,dstIpv4Addr,srcPort,dstPort,energy,false);
}
else
{
m_rtable-><API key> (energy);
}
}
}
if(std::abs(<API key>)>1)
{
NS_LOG_VB("remainedEnergyError " << systemB << " " << remainedEnergy);
}
else
{
//NS_LOG_VB("remainedEnergy " << systemB << " " << remainedEnergy);
}
m_rtable->setSystemB (remainedEnergy);
}
void
HwmpProtocol::GammaChange(double gamma, double totalSimmTime)
{
<API key>=totalSimmTime;
double <API key>=<API key>::Now ().GetSeconds ();
double <API key>=<API key>*0.035;
//double <API key>=<API key>*0;
double bPrim=m_rtable->bPrim ()+m_rtable->controlB ();
double gammaPrim=m_rtable->gammaPrim ()+m_rtable->controlGamma ();
double assignedGamma=m_rtable->assignedGamma ()-m_rtable->controlGamma ();
if(bPrim>=<API key>)
{
m_rtable->setControlB (<API key>);
m_rtable->setControlBMax (<API key>);
m_rtable->setControlGamma (0);
bPrim-=<API key>;
}
else
{
m_rtable->setControlB (bPrim);
m_rtable->setControlBMax (<API key>);
bPrim=0;
double neededControlGamma=(<API key>)/<API key>;
if(gammaPrim>=neededControlGamma)
{
m_rtable->setControlGamma (neededControlGamma);
gammaPrim-=neededControlGamma;
assignedGamma+=neededControlGamma;
}
else
{
m_rtable->setControlGamma (gammaPrim);
assignedGamma+=gammaPrim;
gammaPrim=0;
}
}
m_rtable->setSystemGamma (gamma);
m_rtable->setBPrim (bPrim);
m_rtable->setGammaPrim (gammaPrim);
m_rtable->setAssignedGamma (assignedGamma);
NS_LOG_VB("GammaChange " << gamma << " " << totalSimmTime << " | " << m_rtable->systemGamma () << " " << m_rtable->bPrim () << " " << m_rtable->gammaPrim () << " " << m_rtable->assignedGamma () << " * " << m_rtable->controlGamma () << " " << m_rtable->controlB ());
}
//Statistics:
HwmpProtocol::Statistics::Statistics () :
txUnicast (0),
txBroadcast (0),
txBytes (0),
droppedTtl (0),
totalQueued (0),
totalDropped (0),
initiatedPreq (0),
initiatedPrep (0),
initiatedPerr (0)
{
}
void HwmpProtocol::Statistics::Print (std::ostream & os) const
{
os << "<Statistics "
"txUnicast=\"" << txUnicast << "\" "
"txBroadcast=\"" << txBroadcast << "\" "
"txBytes=\"" << txBytes << "\" "
"droppedTtl=\"" << droppedTtl << "\" "
"totalQueued=\"" << totalQueued << "\" "
"totalDropped=\"" << totalDropped << "\" "
"initiatedPreq=\"" << initiatedPreq << "\" "
"initiatedPrep=\"" << initiatedPrep << "\" "
"initiatedPerr=\"" << initiatedPerr << "\"/>" << std::endl;
}
void
HwmpProtocol::Report (std::ostream & os) const
{
os << "<Hwmp "
"address=\"" << m_address << "\"" << std::endl <<
"maxQueueSize=\"" << m_maxQueueSize << "\"" << std::endl <<
"<API key>=\"" << (uint16_t)<API key> << "\"" << std::endl <<
"<API key>=\"" << <API key>.GetSeconds () << "\"" << std::endl <<
"<API key>=\"" << <API key>.GetSeconds () << "\"" << std::endl <<
"<API key>=\"" << <API key>.GetSeconds () << "\"" << std::endl <<
"<API key>=\"" << <API key>.GetSeconds () << "\"" << std::endl <<
"<API key>=\"" << <API key>.GetSeconds () << "\"" << std::endl <<
"<API key>=\"" << <API key>.GetSeconds () << "\"" << std::endl <<
"<API key>=\"" << <API key>.GetSeconds () << "\"" << std::endl <<
"isRoot=\"" << m_isRoot << "\"" << std::endl <<
"maxTtl=\"" << (uint16_t)m_maxTtl << "\"" << std::endl <<
"<API key>=\"" << (uint16_t)<API key> << "\"" << std::endl <<
"<API key>=\"" << (uint16_t)<API key> << "\"" << std::endl <<
"<API key>=\"" << (uint16_t)<API key> << "\"" << std::endl <<
"doFlag=\"" << m_doFlag << "\"" << std::endl <<
"rfFlag=\"" << m_rfFlag << "\">" << std::endl;
m_stats.Print (os);
for (HwmpProtocolMacMap::const_iterator plugin = m_interfaces.begin (); plugin != m_interfaces.end (); plugin++)
{
plugin->second->Report (os);
}
os << "</Hwmp>" << std::endl;
}
void
HwmpProtocol::ResetStats ()
{
m_stats = Statistics ();
for (HwmpProtocolMacMap::const_iterator plugin = m_interfaces.begin (); plugin != m_interfaces.end (); plugin++)
{
plugin->second->ResetStats ();
}
}
int64_t
HwmpProtocol::AssignStreams (int64_t stream)
{
NS_LOG_FUNCTION (this << stream);
m_coefficient->SetStream (stream);
return 1;
}
double HwmpProtocol::GetSumRhoPps()
{
return m_rtable->GetSumRhoPps ();
}
double HwmpProtocol::GetSumGPps()
{
return m_rtable->GetSumGPps ();
}
HwmpProtocol::QueuedPacket::QueuedPacket () :
pkt (0),
protocol (0),
inInterface (0)
{
}
} // namespace dot11s
} // namespace ns3
|
/* $Id: gp_stdia.c,v 1.5 2002/02/21 22:24:52 giles Exp $ */
/* Read stdin on platforms that support unbuffered read. */
/* We want unbuffered for console input and pipes. */
#include "stdio_.h"
#include "time_.h"
#include "unistd_.h"
#include "gx.h"
#include "gp.h"
/* Read bytes from stdin, unbuffered if possible. */
int gp_stdin_read(char *buf, int len, int interactive, FILE *f)
{
return read(fileno(f), buf, len);
}
|
This program is free software; you can redistribute it and/or modify
## (at your option) any later version.
## This program is distributed in the hope that it will be useful,
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## along with this program; if not, write to the Free Software
## Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
from sos.plugins import Plugin, RedHatPlugin, DebianPlugin, UbuntuPlugin
class SysVIPC(Plugin, RedHatPlugin, DebianPlugin, UbuntuPlugin):
"""SysV IPC related information
"""
plugin_name = "sysvipc"
def setup(self):
self.add_copy_specs([
"/proc/sysvipc/msg",
"/proc/sysvipc/sem",
"/proc/sysvipc/shm"
])
self.add_cmd_output("ipcs")
# vim: et ts=4 sw=4
|
package se.sics.kola.node;
import se.sics.kola.analysis.*;
@SuppressWarnings("nls")
public final class AClassFieldAccess extends PFieldAccess
{
private PClassName _className_;
private TIdentifier _identifier_;
public AClassFieldAccess()
{
// Constructor
}
public AClassFieldAccess(
@SuppressWarnings("hiding") PClassName _className_,
@SuppressWarnings("hiding") TIdentifier _identifier_)
{
// Constructor
setClassName(_className_);
setIdentifier(_identifier_);
}
@Override
public Object clone()
{
return new AClassFieldAccess(
cloneNode(this._className_),
cloneNode(this._identifier_));
}
@Override
public void apply(Switch sw)
{
((Analysis) sw).<API key>(this);
}
public PClassName getClassName()
{
return this._className_;
}
public void setClassName(PClassName node)
{
if(this._className_ != null)
{
this._className_.parent(null);
}
if(node != null)
{
if(node.parent() != null)
{
node.parent().removeChild(node);
}
node.parent(this);
}
this._className_ = node;
}
public TIdentifier getIdentifier()
{
return this._identifier_;
}
public void setIdentifier(TIdentifier node)
{
if(this._identifier_ != null)
{
this._identifier_.parent(null);
}
if(node != null)
{
if(node.parent() != null)
{
node.parent().removeChild(node);
}
node.parent(this);
}
this._identifier_ = node;
}
@Override
public String toString()
{
return ""
+ toString(this._className_)
+ toString(this._identifier_);
}
@Override
void removeChild(@SuppressWarnings("unused") Node child)
{
// Remove child
if(this._className_ == child)
{
this._className_ = null;
return;
}
if(this._identifier_ == child)
{
this._identifier_ = null;
return;
}
throw new RuntimeException("Not a child.");
}
@Override
void replaceChild(@SuppressWarnings("unused") Node oldChild, @SuppressWarnings("unused") Node newChild)
{
// Replace child
if(this._className_ == oldChild)
{
setClassName((PClassName) newChild);
return;
}
if(this._identifier_ == oldChild)
{
setIdentifier((TIdentifier) newChild);
return;
}
throw new RuntimeException("Not a child.");
}
}
|
package com.pingdynasty.blipbox;
import java.util.Map;
import java.util.HashMap;
import javax.sound.midi.*;
import com.pingdynasty.midi.ScaleMapper;
import org.apache.log4j.Logger;
public class <API key> extends <API key> {
private static final Logger log = Logger.getLogger(<API key>.class);
private static final int OCTAVE_SHIFT = 6;
private MidiPlayer midiPlayer;
private int lastNote = 0;
public class <API key> extends ConfigurationMode {
private ScaleMapper mapper;
private int basenote = 40;
public <API key>(String name, String follow){
super(name, follow);
mapper = new ScaleMapper();
mapper.setScale("Mixolydian Mode");
// setScale("Chromatic Scale");
// setScale("C Major");
// setScale("Dorian Mode");
}
public ScaleMapper getScaleMapper(){
return mapper;
}
public int getBaseNote(){
return basenote;
}
public void setBaseNote(int basenote){
this.basenote = basenote;
}
}
public ConfigurationMode <API key>(String mode, String follow){
return new <API key>(mode, follow);
}
public ScaleMapper getScaleMapper(){
<API key> mode = (<API key>)<API key>();
return mode.getScaleMapper();
}
public ScaleMapper getScaleMapper(String mode){
<API key> config = (<API key>)<API key>(mode);
return config.getScaleMapper();
}
public int getBaseNote(){
<API key> mode = (<API key>)<API key>();
return mode.getBaseNote();
}
public void setBaseNote(int basenote){
<API key> mode = (<API key>)<API key>();
mode.setBaseNote(basenote);
}
public void setBaseNote(String modename, int basenote){
<API key> mode = (<API key>)<API key>(modename);
mode.setBaseNote(basenote);
}
public void holdOff(){
super.holdOff();
sendMidiNoteOff(lastNote);
}
public void init(){
super.init();
<API key>("Cross", SensorType.BUTTON2_SENSOR, new <API key>());
<API key>("Cross", SensorType.BUTTON3_SENSOR, new <API key>());
<API key>("Criss", SensorType.BUTTON2_SENSOR, new <API key>());
<API key>("Criss", SensorType.BUTTON3_SENSOR, new <API key>());
}
public class <API key> implements SensorEventHandler {
public void sensorChange(SensorDefinition sensor){
if(sensor.value != 0){
int basenote = getBaseNote();
log.debug("octave up");
basenote += OCTAVE_SHIFT;
if(basenote + OCTAVE_SHIFT <= 127)
setBaseNote(basenote);
log.debug("new basenote "+basenote);
}
}
}
public class <API key> implements SensorEventHandler {
public void sensorChange(SensorDefinition sensor){
if(sensor.value != 0){
int basenote = getBaseNote();
log.debug("octave down");
basenote -= OCTAVE_SHIFT;
if(basenote > 0)
setBaseNote(basenote);
log.debug("new basenote "+basenote);
}
}
}
public class <API key> implements SensorEventHandler {
private int min, max;
public <API key>(){
this(0, 127);
}
public <API key>(int min, int max){
this.min = min;
this.max = max;
}
public void sensorChange(SensorDefinition sensor){
int basenote = sensor.scale(min, max);
log.debug("basenote: "+basenote);
setBaseNote(basenote);
}
}
public class <API key> implements SensorEventHandler {
public void sensorChange(SensorDefinition sensor){
ScaleMapper mapper = getScaleMapper();
int val = sensor.scale(mapper.getScaleNames().length);
if(val < mapper.getScaleNames().length){
mapper.setScale(val);
log.debug("set scale "+mapper.getScaleNames()[val]);
}
}
}
public class <API key> implements SensorEventHandler {
private int from;
private int to;
private int cc;
public <API key>(int cc){
this(cc, 0, 127);
}
public <API key>(int cc, int from, int to){
this.from = from;
this.to = to;
this.cc = cc;
}
public void sensorChange(SensorDefinition sensor){
int val = sensor.scale(from, to);
sendMidiCC(cc, val);
}
}
public class <API key> implements SensorEventHandler {
private int from;
private int to;
private int cc;
public <API key>(int cc, int from, int to){
this.from = from;
this.to = to;
this.cc = cc;
}
public void sensorChange(SensorDefinition sensor){
int val = sensor.scale(from, to);
sendMidiNRPN(cc, val);
}
}
public class <API key> implements SensorEventHandler {
private int from;
private int to;
public <API key>(){
this(-8191, 8192);
}
public <API key>(int from, int to){
this.from = from;
this.to = to;
}
public void sensorChange(SensorDefinition sensor){
int val = sensor.scale(from, to);
sendMidiPitchBend(val);
}
}
public class NotePlayer implements KeyEventHandler {
private int lastnote;
public void sensorChange(SensorDefinition sensor){}
protected int getVelocity(int row){
// int velocity = ((row+1)*127/8);
// int velocity = (row*127/8)+1;
int velocity = ((row+1)*127/9);
return velocity;
}
public void keyDown(int col, int row){
lastNote = getScaleMapper().getNote(col+getBaseNote());
sendMidiNoteOn(lastNote, getVelocity(row));
}
public void keyUp(int col, int row){
sendMidiNoteOff(lastNote);
}
public void keyChange(int oldCol, int oldRow, int newCol, int newRow){
int newNote = getScaleMapper().getNote(newCol+getBaseNote());
if(newNote != lastNote){
sendMidiNoteOff(lastNote);
sendMidiNoteOn(newNote, getVelocity(newRow));
}
lastNote = newNote;
}
}
public <API key>(BlipBox sender){
super(sender);
}
public void <API key>(String mode, SensorType type, int channel, int cc, int min, int max){
log.debug("Setting "+mode+":"+type+" to CC "+cc+" ("+min+"-"+max+")");
<API key>(mode, type, new <API key>(cc, min, max));
}
public void configureNRPN(String mode, SensorType type, int channel, int cc, int min, int max){
log.debug("Setting "+mode+":"+type+" to NRPN "+cc+" ("+min+"-"+max+")");
<API key>(mode, type, new <API key>(cc, min, max));
}
public void configurePitchBend(String mode, SensorType type, int channel, int min, int max){
<API key>(mode, type, new <API key>(min, max));
}
public void <API key>(String mode, SensorType type, int min, int max){
log.debug("Setting "+mode+":"+type+" to control base note");
<API key>(mode, type, new <API key>(min, max));
}
public void <API key>(String mode, SensorType type){
log.debug("Setting "+mode+":"+type+" to control scale changes");
<API key>(mode, type, new <API key>());
}
public void configureNotePlayer(String mode, boolean notes, boolean pb, boolean at){
log.debug("Setting "+mode+" mode to play notes ("+notes+") pitch bend ("+pb+") aftertouch ("+at+")");
if(notes){
setKeyEventHandler(mode, new NotePlayer());
}else{
setKeyEventHandler(mode, null);
}
// todo: honour pb and at
}
// public String[] getScaleNames(){
// return mapper.getScaleNames();
// public void setScale(int index){
// mapper.setScale(index);
public String getCurrentScale(){
ScaleMapper mapper = getScaleMapper();
return mapper.getScaleNames()[mapper.getScaleIndex()];
}
public void setMidiPlayer(MidiPlayer midiPlayer){
this.midiPlayer = midiPlayer;
}
public void sendMidiNoteOn(int note, int velocity){
log.debug("note on:\t "+note+"\t "+velocity);
if(note > 127 || note < 0){
log.error("MIDI note on "+note+"/"+velocity+" value out of range");
return;
}
if(velocity > 127 || velocity < 0){
log.error("MIDI note on "+note+"/"+velocity+" value out of range");
velocity = velocity < 0 ? 0 : 127;
}
try {
if(midiPlayer != null)
midiPlayer.noteOn(note, velocity);
}catch(Exception exc){
log.error(exc, exc);
}
}
public void sendMidiNoteOff(int note){
// note = mapper.getNote(note);
log.debug("note off:\t "+note);
if(note > 127 || note < 0){
log.error("MIDI note off "+note+" value out of range");
return;
}
try {
if(midiPlayer != null)
midiPlayer.noteOff(note);
}catch(Exception exc){
log.error(exc, exc);
}
}
public void sendMidiNRPN(int parameter, int value){
// log.debug("nrpn ("+parameter+") :\t "+value);
sendMidiCC(99, 3);
sendMidiCC(98, parameter & 0x7f); // NRPN LSB
sendMidiCC(6, value);
// sendMidiCC(99, parameter >> 7); // NRPN MSB
// sendMidiCC(98, parameter & 0x7f); // NRPN LSB
// sendMidiCC(6, value >> 7); // Data Entry MSB
// if((value & 0x7f) != 0)
// sendMidiCC(38, value & 0x7f); // Data Entry LSB
}
public void sendMidiCC(int cc, int value){
// log.debug("midi cc:\t "+cc+"\t "+value);
if(value > 127 || value < 0){
log.error("MIDI CC "+cc+" value out of range: "+value);
return;
}
try {
if(midiPlayer != null)
midiPlayer.controlChange(cc, value);
}catch(Exception exc){
log.error(exc, exc);
}
}
public void sendMidiPitchBend(int degree){
// send midi pitch bend in the range -8192 to 8191 inclusive
if(degree < -8192 || degree > 8191){
log.error("MIDI pitch bend value out of range: "+degree);
return;
}
// setPitchBend() expects a value in the range 0 to 16383
degree += 8192;
try {
if(midiPlayer != null)
midiPlayer.pitchBend(degree);
}catch(Exception exc){
log.error(exc, exc);
}
}
public void setChannel(int channel){
midiPlayer.setChannel(channel);
}
public class SensitiveNotePlayer implements KeyEventHandler {
private int lastnote;
private int velocity;
// todo : velocity could be set by row rather than sensor position
public void sensorChange(SensorDefinition sensor){
velocity = sensor.scale(127);
}
public void keyDown(int col, int row){
lastNote = getScaleMapper().getNote(col+getBaseNote());
sendMidiNoteOn(lastNote, velocity);
}
public void keyUp(int col, int row){
sendMidiNoteOff(lastNote);
}
public void keyChange(int oldCol, int oldRow, int newCol, int newRow){
int newNote = getScaleMapper().getNote(newCol+getBaseNote());
if(newNote != lastNote){
sendMidiNoteOff(lastNote);
sendMidiNoteOn(newNote, velocity);
// }else{
// // todo: aftertouch, bend
}
lastNote = newNote;
}
}
}
|
/*
* @test
* @bug 4853450
* @summary EnumType tests
* @library ../../lib
* @compile -source 1.5 EnumTyp.java
* @run main EnumTyp
*/
import java.util.*;
import com.sun.mirror.declaration.*;
import com.sun.mirror.type.*;
import com.sun.mirror.util.*;
public class EnumTyp extends Tester {
public static void main(String[] args) {
(new EnumTyp()).run();
}
// Declarations used by tests
enum Suit {
CIVIL,
CRIMINAL
}
private Suit s;
private EnumType e; // an enum type
protected void init() {
e = (EnumType) getField("s").getType();
}
// TypeMirror methods
@Test(result="enum")
Collection<String> accept() {
final Collection<String> res = new ArrayList<String>();
e.accept(new SimpleTypeVisitor() {
public void visitTypeMirror(TypeMirror t) {
res.add("type");
}
public void visitReferenceType(ReferenceType t) {
res.add("ref type");
}
public void visitClassType(ClassType t) {
res.add("class");
}
public void visitEnumType(EnumType t) {
res.add("enum");
}
public void visitInterfaceType(InterfaceType t) {
res.add("interface");
}
});
return res;
}
// EnumType method
@Test(result="EnumTyp.Suit")
EnumDeclaration getDeclaration() {
return e.getDeclaration();
}
}
|
#define pr_fmt(fmt) "QCE50: %s: " fmt, __func__
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mod_devicetable.h>
#include <linux/device.h>
#include <linux/clk.h>
#include <linux/err.h>
#include <linux/dma-mapping.h>
#include <linux/io.h>
#include <linux/platform_device.h>
#include <linux/spinlock.h>
#include <linux/delay.h>
#include <linux/crypto.h>
#include <linux/qcedev.h>
#include <linux/bitops.h>
#include <crypto/hash.h>
#include <crypto/sha.h>
#include <mach/dma.h>
#include <mach/clk.h>
#include <mach/socinfo.h>
#include <mach/qcrypto.h>
#include "qce.h"
#include "qce50.h"
#include "qcryptohw_50.h"
#define CRYPTO_CONFIG_RESET 0xE001F
#define QCE_MAX_NUM_DSCR 0x500
#define QCE_SECTOR_SIZE 0x200
static DEFINE_MUTEX(bam_register_cnt);
struct <API key> {
uint32_t handle;
uint32_t cnt;
};
static struct <API key> bam_registry;
static bool ce_bam_registered;
/*
* CE HW device structure.
* Each engine has an instance of the structure.
* Each engine can only handle one crypto operation at one time. It is up to
* the sw above to ensure single threading of operation on an engine.
*/
struct qce_device {
struct device *pdev; /* Handle to platform_device structure */
unsigned char *coh_vmem; /* Allocated coherent virtual memory */
dma_addr_t coh_pmem; /* Allocated coherent physical memory */
int memsize; /* Memory allocated */
int is_shared; /* CE HW is shared */
bool support_cmd_dscr;
bool support_hw_key;
void __iomem *iobase; /* Virtual io base of CE HW */
unsigned int phy_iobase; /* Physical io base of CE HW */
struct clk *ce_core_src_clk; /* Handle to CE src clk*/
struct clk *ce_core_clk; /* Handle to CE clk */
struct clk *ce_clk; /* Handle to CE clk */
struct clk *ce_bus_clk; /* Handle to CE AXI clk*/
qce_comp_func_ptr_t qce_cb; /* qce callback function pointer */
int assoc_nents;
int ivsize;
int authsize;
int src_nents;
int dst_nents;
dma_addr_t phy_iv_in;
unsigned char dec_iv[16];
int dir;
void *areq;
enum <API key> mode;
struct <API key> reg;
struct ce_sps_data ce_sps;
};
/* Standard initialization vector for SHA-1, source: FIPS 180-2 */
static uint32_t <API key>[] = {
0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0
};
/* Standard initialization vector for SHA-256, source: FIPS 180-2 */
static uint32_t <API key>[] = {
0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
};
static void <API key>(uint32_t *iv, unsigned char *b,
unsigned int len)
{
unsigned n;
n = len / sizeof(uint32_t) ;
for (; n > 0; n
*iv = ((*b << 24) & 0xff000000) |
(((*(b+1)) << 16) & 0xff0000) |
(((*(b+2)) << 8) & 0xff00) |
(*(b+3) & 0xff);
b += sizeof(uint32_t);
iv++;
}
n = len % sizeof(uint32_t);
if (n == 3) {
*iv = ((*b << 24) & 0xff000000) |
(((*(b+1)) << 16) & 0xff0000) |
(((*(b+2)) << 8) & 0xff00) ;
} else if (n == 2) {
*iv = ((*b << 24) & 0xff000000) |
(((*(b+1)) << 16) & 0xff0000) ;
} else if (n == 1) {
*iv = ((*b << 24) & 0xff000000) ;
}
}
static void <API key>(uint32_t *iv, unsigned char *b,
unsigned int len)
{
unsigned i, j;
unsigned char swap_iv[AES_IV_LENGTH];
memset(swap_iv, 0, AES_IV_LENGTH);
for (i = (AES_IV_LENGTH-len), j = len-1; i < AES_IV_LENGTH; i++, j
swap_iv[i] = b[j];
<API key>(iv, swap_iv, AES_IV_LENGTH);
}
static int count_sg(struct scatterlist *sg, int nbytes)
{
int i;
for (i = 0; nbytes > 0; i++, sg = scatterwalk_sg_next(sg))
nbytes -= sg->length;
return i;
}
static int qce_dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
enum dma_data_direction direction)
{
int i;
for (i = 0; i < nents; ++i) {
dma_map_sg(dev, sg, 1, direction);
sg = scatterwalk_sg_next(sg);
}
return nents;
}
static int qce_dma_unmap_sg(struct device *dev, struct scatterlist *sg,
int nents, enum dma_data_direction direction)
{
int i;
for (i = 0; i < nents; ++i) {
dma_unmap_sg(dev, sg, 1, direction);
sg = scatterwalk_sg_next(sg);
}
return nents;
}
static int _probe_ce_engine(struct qce_device *pce_dev)
{
unsigned int rev;
unsigned int maj_rev, min_rev, step_rev;
rev = readl_relaxed(pce_dev->iobase + CRYPTO_VERSION_REG);
mb();
maj_rev = (rev & <API key>) >> <API key>;
min_rev = (rev & <API key>) >> <API key>;
step_rev = (rev & <API key>) >> <API key>;
if (maj_rev != 0x05) {
pr_err("Unknown Qualcomm crypto device at 0x%x, rev %d.%d.%d\n",
pce_dev->phy_iobase, maj_rev, min_rev, step_rev);
return -EIO;
};
pce_dev->ce_sps.minor_version = min_rev;
dev_info(pce_dev->pdev, "Qualcomm Crypto %d.%d.%d device found @0x%x\n",
maj_rev, min_rev, step_rev, pce_dev->phy_iobase);
pce_dev->ce_sps.ce_burst_size = <API key>;
dev_info(pce_dev->pdev,
"IO base, CE = 0x%x\n, "
"Consumer (IN) PIPE %d, "
"Producer (OUT) PIPE %d\n"
"IO base BAM = 0x%x\n"
"BAM IRQ %d\n",
(uint32_t) pce_dev->iobase,
pce_dev->ce_sps.dest_pipe_index,
pce_dev->ce_sps.src_pipe_index,
(uint32_t)pce_dev->ce_sps.bam_iobase,
pce_dev->ce_sps.bam_irq);
return 0;
};
static int <API key>(struct qce_device *pce_dev,
struct qce_sha_req *sreq,
struct qce_cmdlist_info **cmdplistinfo)
{
struct qce_cmdlistptr_ops *cmdlistptr = &pce_dev->ce_sps.cmdlistptr;
switch (sreq->alg) {
case QCE_HASH_SHA1:
*cmdplistinfo = &cmdlistptr->auth_sha1;
break;
case QCE_HASH_SHA256:
*cmdplistinfo = &cmdlistptr->auth_sha256;
break;
case QCE_HASH_SHA1_HMAC:
*cmdplistinfo = &cmdlistptr->auth_sha1_hmac;
break;
case <API key>:
*cmdplistinfo = &cmdlistptr->auth_sha256_hmac;
break;
case QCE_HASH_AES_CMAC:
if (sreq->authklen == AES128_KEY_SIZE)
*cmdplistinfo = &cmdlistptr->auth_aes_128_cmac;
else
*cmdplistinfo = &cmdlistptr->auth_aes_256_cmac;
break;
default:
break;
}
return 0;
}
static int _ce_setup_hash(struct qce_device *pce_dev,
struct qce_sha_req *sreq,
struct qce_cmdlist_info *cmdlistinfo)
{
uint32_t auth32[SHA256_DIGEST_SIZE / sizeof(uint32_t)];
uint32_t diglen;
int i;
uint32_t mackey32[SHA_HMAC_KEY_SIZE/sizeof(uint32_t)] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
bool sha1 = false;
struct sps_command_element *pce = NULL;
if ((sreq->alg == QCE_HASH_SHA1_HMAC) ||
(sreq->alg == <API key>) ||
(sreq->alg == QCE_HASH_AES_CMAC)) {
uint32_t authk_size_in_word = sreq->authklen/sizeof(uint32_t);
<API key>(mackey32, sreq->authkey,
sreq->authklen);
/* check for null key. If null, use hw key*/
for (i = 0; i < authk_size_in_word; i++) {
if (mackey32[i] != 0)
break;
}
pce = cmdlistinfo->go_proc;
if (i == authk_size_in_word) {
pce->addr = (uint32_t)(<API key> +
pce_dev->phy_iobase);
} else {
pce->addr = (uint32_t)(CRYPTO_GOPROC_REG +
pce_dev->phy_iobase);
pce = cmdlistinfo->auth_key;
for (i = 0; i < authk_size_in_word; i++, pce++)
pce->data = mackey32[i];
}
}
if (sreq->alg == QCE_HASH_AES_CMAC)
goto go_proc;
/* if not the last, the size has to be on the block boundary */
if (sreq->last_blk == 0 && (sreq->size % SHA256_BLOCK_SIZE))
return -EIO;
switch (sreq->alg) {
case QCE_HASH_SHA1:
case QCE_HASH_SHA1_HMAC:
diglen = SHA1_DIGEST_SIZE;
sha1 = true;
break;
case QCE_HASH_SHA256:
case <API key>:
diglen = SHA256_DIGEST_SIZE;
break;
default:
return -EINVAL;
}
/* write 20/32 bytes, 5/8 words into auth_iv for SHA1/SHA256 */
if (sreq->first_blk) {
if (sha1) {
for (i = 0; i < 5; i++)
auth32[i] = <API key>[i];
} else {
for (i = 0; i < 8; i++)
auth32[i] = <API key>[i];
}
} else {
<API key>(auth32, sreq->digest, diglen);
}
pce = cmdlistinfo->auth_iv;
for (i = 0; i < 5; i++, pce++)
pce->data = auth32[i];
if ((sreq->alg == QCE_HASH_SHA256) ||
(sreq->alg == <API key>)) {
for (i = 5; i < 8; i++, pce++)
pce->data = auth32[i];
}
/* write auth_bytecnt 0/1, start with 0 */
pce = cmdlistinfo->auth_bytecount;
for (i = 0; i < 2; i++, pce++)
pce->data = sreq->auth_data[i];
/* Set/reset last bit in CFG register */
pce = cmdlistinfo->auth_seg_cfg;
if (sreq->last_blk)
pce->data |= 1 << CRYPTO_LAST;
else
pce->data &= ~(1 << CRYPTO_LAST);
if (sreq->first_blk)
pce->data |= 1 << CRYPTO_FIRST;
else
pce->data &= ~(1 << CRYPTO_FIRST);
go_proc:
/* write auth seg size */
pce = cmdlistinfo->auth_seg_size;
pce->data = sreq->size;
pce = cmdlistinfo->encr_seg_cfg;
pce->data = 0;
/* write auth seg size start*/
pce = cmdlistinfo->auth_seg_start;
pce->data = 0;
/* write seg size */
pce = cmdlistinfo->seg_size;
pce->data = sreq->size;
return 0;
}
static struct qce_cmdlist_info *<API key>(
struct qce_device *pce_dev, struct qce_req *creq)
{
switch (creq->alg) {
case CIPHER_ALG_DES:
switch (creq->mode) {
case QCE_MODE_ECB:
return &pce_dev->ce_sps.
cmdlistptr.<API key>;
break;
case QCE_MODE_CBC:
return &pce_dev->ce_sps.
cmdlistptr.<API key>;
break;
default:
return NULL;
}
break;
case CIPHER_ALG_3DES:
switch (creq->mode) {
case QCE_MODE_ECB:
return &pce_dev->ce_sps.
cmdlistptr.<API key>;
break;
case QCE_MODE_CBC:
return &pce_dev->ce_sps.
cmdlistptr.<API key>;
break;
default:
return NULL;
}
break;
case CIPHER_ALG_AES:
switch (creq->mode) {
case QCE_MODE_ECB:
if (creq->encklen == AES128_KEY_SIZE)
return &pce_dev->ce_sps.
cmdlistptr.<API key>;
else if (creq->encklen == AES256_KEY_SIZE)
return &pce_dev->ce_sps.
cmdlistptr.<API key>;
else
return NULL;
break;
case QCE_MODE_CBC:
if (creq->encklen == AES128_KEY_SIZE)
return &pce_dev->ce_sps.
cmdlistptr.<API key>;
else if (creq->encklen == AES256_KEY_SIZE)
return &pce_dev->ce_sps.
cmdlistptr.<API key>;
else
return NULL;
break;
default:
return NULL;
}
break;
default:
return NULL;
}
return NULL;
}
static int _ce_setup_aead(struct qce_device *pce_dev, struct qce_req *q_req,
uint32_t totallen_in, uint32_t coffset,
struct qce_cmdlist_info *cmdlistinfo)
{
int32_t authk_size_in_word = q_req->authklen/sizeof(uint32_t);
int i;
uint32_t mackey32[SHA_HMAC_KEY_SIZE/sizeof(uint32_t)] = {0};
struct sps_command_element *pce;
uint32_t a_cfg;
uint32_t enckey32[(MAX_CIPHER_KEY_SIZE*2)/sizeof(uint32_t)] = {0};
uint32_t enciv32[MAX_IV_LENGTH/sizeof(uint32_t)] = {0};
uint32_t enck_size_in_word = 0;
uint32_t enciv_in_word;
uint32_t key_size;
uint32_t encr_cfg = 0;
uint32_t ivsize = q_req->ivsize;
key_size = q_req->encklen;
enck_size_in_word = key_size/sizeof(uint32_t);
switch (q_req->alg) {
case CIPHER_ALG_DES:
enciv_in_word = 2;
break;
case CIPHER_ALG_3DES:
enciv_in_word = 2;
break;
case CIPHER_ALG_AES:
if ((key_size != AES128_KEY_SIZE) &&
(key_size != AES256_KEY_SIZE))
return -EINVAL;
enciv_in_word = 4;
break;
default:
return -EINVAL;
}
switch (q_req->mode) {
case QCE_MODE_ECB:
case QCE_MODE_CBC:
case QCE_MODE_CTR:
pce_dev->mode = q_req->mode;
break;
default:
return -EINVAL;
}
if (q_req->mode != QCE_MODE_ECB) {
<API key>(enciv32, q_req->iv, ivsize);
pce = cmdlistinfo->encr_cntr_iv;
for (i = 0; i < enciv_in_word; i++, pce++)
pce->data = enciv32[i];
}
/*
* write encr key
* do not use hw key or pipe key
*/
<API key>(enckey32, q_req->enckey, key_size);
pce = cmdlistinfo->encr_key;
for (i = 0; i < enck_size_in_word; i++, pce++)
pce->data = enckey32[i];
/* write encr seg cfg */
pce = cmdlistinfo->encr_seg_cfg;
encr_cfg = pce->data;
if (q_req->dir == QCE_ENCRYPT)
encr_cfg |= (1 << CRYPTO_ENCODE);
else
encr_cfg &= ~(1 << CRYPTO_ENCODE);
pce->data = encr_cfg;
/* we only support sha1-hmac at this point */
<API key>(mackey32, q_req->authkey,
q_req->authklen);
pce = cmdlistinfo->auth_key;
for (i = 0; i < authk_size_in_word; i++, pce++)
pce->data = mackey32[i];
pce = cmdlistinfo->auth_iv;
for (i = 0; i < 5; i++, pce++)
pce->data = <API key>[i];
/* write auth_bytecnt 0/1, start with 0 */
pce = cmdlistinfo->auth_bytecount;
for (i = 0; i < 2; i++, pce++)
pce->data = 0;
pce = cmdlistinfo->auth_seg_cfg;
a_cfg = pce->data;
a_cfg &= ~(<API key>);
if (q_req->dir == QCE_ENCRYPT)
a_cfg |= (<API key> << CRYPTO_AUTH_POS);
else
a_cfg |= (<API key> << CRYPTO_AUTH_POS);
pce->data = a_cfg;
/* write auth seg size */
pce = cmdlistinfo->auth_seg_size;
pce->data = totallen_in;
/* write auth seg size start*/
pce = cmdlistinfo->auth_seg_start;
pce->data = 0;
/* write seg size */
pce = cmdlistinfo->seg_size;
pce->data = totallen_in;
/* write encr seg size */
pce = cmdlistinfo->encr_seg_size;
pce->data = q_req->cryptlen;
/* write encr seg start */
pce = cmdlistinfo->encr_seg_start;
pce->data = (coffset & 0xffff);
return 0;
};
static int <API key>(struct qce_device *pce_dev,
struct qce_req *creq,
struct qce_cmdlist_info **cmdlistinfo)
{
struct qce_cmdlistptr_ops *cmdlistptr = &pce_dev->ce_sps.cmdlistptr;
if (creq->alg != CIPHER_ALG_AES) {
switch (creq->alg) {
case CIPHER_ALG_DES:
if (creq->mode == QCE_MODE_ECB)
*cmdlistinfo = &cmdlistptr->cipher_des_ecb;
else
*cmdlistinfo = &cmdlistptr->cipher_des_cbc;
break;
case CIPHER_ALG_3DES:
if (creq->mode == QCE_MODE_ECB)
*cmdlistinfo =
&cmdlistptr->cipher_3des_ecb;
else
*cmdlistinfo =
&cmdlistptr->cipher_3des_cbc;
break;
default:
break;
}
} else {
switch (creq->mode) {
case QCE_MODE_ECB:
if (creq->encklen == AES128_KEY_SIZE)
*cmdlistinfo = &cmdlistptr->cipher_aes_128_ecb;
else
*cmdlistinfo = &cmdlistptr->cipher_aes_256_ecb;
break;
case QCE_MODE_CBC:
case QCE_MODE_CTR:
if (creq->encklen == AES128_KEY_SIZE)
*cmdlistinfo =
&cmdlistptr-><API key>;
else
*cmdlistinfo =
&cmdlistptr-><API key>;
break;
case QCE_MODE_XTS:
if (creq->encklen/2 == AES128_KEY_SIZE)
*cmdlistinfo = &cmdlistptr->cipher_aes_128_xts;
else
*cmdlistinfo = &cmdlistptr->cipher_aes_256_xts;
break;
case QCE_MODE_CCM:
if (creq->encklen == AES128_KEY_SIZE)
*cmdlistinfo = &cmdlistptr->aead_aes_128_ccm;
else
*cmdlistinfo = &cmdlistptr->aead_aes_256_ccm;
break;
default:
break;
}
}
return 0;
}
static int _ce_setup_cipher(struct qce_device *pce_dev, struct qce_req *creq,
uint32_t totallen_in, uint32_t coffset,
struct qce_cmdlist_info *cmdlistinfo)
{
uint32_t enckey32[(MAX_CIPHER_KEY_SIZE * 2)/sizeof(uint32_t)] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
uint32_t enciv32[MAX_IV_LENGTH / sizeof(uint32_t)] = {
0, 0, 0, 0};
uint32_t enck_size_in_word = 0;
uint32_t key_size;
bool use_hw_key = false;
bool use_pipe_key = false;
uint32_t encr_cfg = 0;
uint32_t ivsize = creq->ivsize;
int i;
struct sps_command_element *pce = NULL;
if (creq->mode == QCE_MODE_XTS)
key_size = creq->encklen/2;
else
key_size = creq->encklen;
pce = cmdlistinfo->go_proc;
if ((creq->flags & <API key>) == <API key>) {
use_hw_key = true;
} else {
if ((creq->flags & <API key>) ==
<API key>)
use_pipe_key = true;
}
pce = cmdlistinfo->go_proc;
if (use_hw_key == true)
pce->addr = (uint32_t)(<API key> +
pce_dev->phy_iobase);
else
pce->addr = (uint32_t)(CRYPTO_GOPROC_REG +
pce_dev->phy_iobase);
if ((use_pipe_key == false) && (use_hw_key == false)) {
<API key>(enckey32, creq->enckey, key_size);
enck_size_in_word = key_size/sizeof(uint32_t);
}
if ((creq->op == QCE_REQ_AEAD) && (creq->mode == QCE_MODE_CCM)) {
uint32_t authklen32 = creq->encklen/sizeof(uint32_t);
uint32_t noncelen32 = MAX_NONCE/sizeof(uint32_t);
uint32_t nonce32[MAX_NONCE/sizeof(uint32_t)] = {0, 0, 0, 0};
uint32_t auth_cfg = 0;
/* write nonce */
<API key>(nonce32, creq->nonce, MAX_NONCE);
pce = cmdlistinfo->auth_nonce_info;
for (i = 0; i < noncelen32; i++, pce++)
pce->data = nonce32[i];
if (creq->authklen == AES128_KEY_SIZE)
auth_cfg = pce_dev->reg.<API key>;
else {
if (creq->authklen == AES256_KEY_SIZE)
auth_cfg = pce_dev->reg.<API key>;
}
if (creq->dir == QCE_ENCRYPT)
auth_cfg |= (<API key> << CRYPTO_AUTH_POS);
else
auth_cfg |= (<API key> << CRYPTO_AUTH_POS);
auth_cfg |= ((creq->authsize - 1) << CRYPTO_AUTH_SIZE);
if (use_hw_key == true) {
auth_cfg |= (1 << <API key>);
} else {
auth_cfg &= ~(1 << <API key>);
/* write auth key */
pce = cmdlistinfo->auth_key;
for (i = 0; i < authklen32; i++, pce++)
pce->data = enckey32[i];
}
pce = cmdlistinfo->auth_seg_cfg;
pce->data = auth_cfg;
pce = cmdlistinfo->auth_seg_size;
if (creq->dir == QCE_ENCRYPT)
pce->data = totallen_in;
else
pce->data = totallen_in - creq->authsize;
pce = cmdlistinfo->auth_seg_start;
pce->data = 0;
} else {
if (creq->op != QCE_REQ_AEAD) {
pce = cmdlistinfo->auth_seg_cfg;
pce->data = 0;
}
}
switch (creq->mode) {
case QCE_MODE_ECB:
if (key_size == AES128_KEY_SIZE)
encr_cfg = pce_dev->reg.<API key>;
else
encr_cfg = pce_dev->reg.<API key>;
break;
case QCE_MODE_CBC:
if (key_size == AES128_KEY_SIZE)
encr_cfg = pce_dev->reg.<API key>;
else
encr_cfg = pce_dev->reg.<API key>;
break;
case QCE_MODE_XTS:
if (key_size == AES128_KEY_SIZE)
encr_cfg = pce_dev->reg.<API key>;
else
encr_cfg = pce_dev->reg.<API key>;
break;
case QCE_MODE_CCM:
if (key_size == AES128_KEY_SIZE)
encr_cfg = pce_dev->reg.<API key>;
else
encr_cfg = pce_dev->reg.<API key>;
encr_cfg |= (<API key> << CRYPTO_ENCR_MODE) |
(CRYPTO_LAST_CCM_XFR << CRYPTO_LAST_CCM);
break;
case QCE_MODE_CTR:
default:
if (key_size == AES128_KEY_SIZE)
encr_cfg = pce_dev->reg.<API key>;
else
encr_cfg = pce_dev->reg.<API key>;
break;
}
pce_dev->mode = creq->mode;
switch (creq->alg) {
case CIPHER_ALG_DES:
if (creq->mode != QCE_MODE_ECB) {
<API key>(enciv32, creq->iv, ivsize);
pce = cmdlistinfo->encr_cntr_iv;
pce->data = enciv32[0];
pce++;
pce->data = enciv32[1];
}
if (use_hw_key == false) {
pce = cmdlistinfo->encr_key;
pce->data = enckey32[0];
pce++;
pce->data = enckey32[1];
}
break;
case CIPHER_ALG_3DES:
if (creq->mode != QCE_MODE_ECB) {
<API key>(enciv32, creq->iv, ivsize);
pce = cmdlistinfo->encr_cntr_iv;
pce->data = enciv32[0];
pce++;
pce->data = enciv32[1];
}
if (use_hw_key == false) {
/* write encr key */
pce = cmdlistinfo->encr_key;
for (i = 0; i < 6; i++, pce++)
pce->data = enckey32[i];
}
break;
case CIPHER_ALG_AES:
default:
if (creq->mode == QCE_MODE_XTS) {
uint32_t xtskey32[MAX_CIPHER_KEY_SIZE/sizeof(uint32_t)]
= {0, 0, 0, 0, 0, 0, 0, 0};
uint32_t xtsklen =
creq->encklen/(2 * sizeof(uint32_t));
if ((use_hw_key == false) && (use_pipe_key == false)) {
<API key>(xtskey32,
(creq->enckey + creq->encklen/2),
creq->encklen/2);
/* write xts encr key */
pce = cmdlistinfo->encr_xts_key;
for (i = 0; i < xtsklen; i++, pce++)
pce->data = xtskey32[i];
}
/* write xts du size */
pce = cmdlistinfo->encr_xts_du_size;
if (!(creq->flags & <API key>))
pce->data = creq->cryptlen;
else
pce->data = min((unsigned int)QCE_SECTOR_SIZE,
creq->cryptlen);
}
if (creq->mode != QCE_MODE_ECB) {
if (creq->mode == QCE_MODE_XTS)
<API key>(enciv32,
creq->iv, ivsize);
else
<API key>(enciv32, creq->iv,
ivsize);
/* write encr cntr iv */
pce = cmdlistinfo->encr_cntr_iv;
for (i = 0; i < 4; i++, pce++)
pce->data = enciv32[i];
if (creq->mode == QCE_MODE_CCM) {
/* write cntr iv for ccm */
pce = cmdlistinfo->encr_ccm_cntr_iv;
for (i = 0; i < 4; i++, pce++)
pce->data = enciv32[i];
/* update cntr_iv[3] by one */
pce = cmdlistinfo->encr_cntr_iv;
pce += 3;
pce->data += 1;
}
}
if (creq->op == <API key>) {
encr_cfg |= (<API key> <<
CRYPTO_ENCR_KEY_SZ);
} else {
if (use_hw_key == false) {
/* write encr key */
pce = cmdlistinfo->encr_key;
for (i = 0; i < enck_size_in_word; i++, pce++)
pce->data = enckey32[i];
}
} /* else of if (creq->op == <API key>) */
break;
} /* end of switch (creq->mode) */
if (use_pipe_key)
encr_cfg |= (<API key>
<< <API key>);
/* write encr seg cfg */
pce = cmdlistinfo->encr_seg_cfg;
if ((creq->alg == CIPHER_ALG_DES) || (creq->alg == CIPHER_ALG_3DES)) {
if (creq->dir == QCE_ENCRYPT)
pce->data |= (1 << CRYPTO_ENCODE);
else
pce->data &= ~(1 << CRYPTO_ENCODE);
encr_cfg = pce->data;
} else {
encr_cfg |=
((creq->dir == QCE_ENCRYPT) ? 1 : 0) << CRYPTO_ENCODE;
}
if (use_hw_key == true)
encr_cfg |= (CRYPTO_USE_HW_KEY << <API key>);
else
encr_cfg &= ~(CRYPTO_USE_HW_KEY << <API key>);
pce->data = encr_cfg;
/* write encr seg size */
pce = cmdlistinfo->encr_seg_size;
if ((creq->mode == QCE_MODE_CCM) && (creq->dir == QCE_DECRYPT))
pce->data = (creq->cryptlen + creq->authsize);
else
pce->data = creq->cryptlen;
/* write encr seg start */
pce = cmdlistinfo->encr_seg_start;
pce->data = (coffset & 0xffff);
/* write seg size */
pce = cmdlistinfo->seg_size;
pce->data = totallen_in;
return 0;
};
static int <API key>(struct qce_device *pce_dev,
struct qce_sha_req *sreq)
{
uint32_t auth32[SHA256_DIGEST_SIZE / sizeof(uint32_t)];
uint32_t diglen;
bool use_hw_key = false;
int i;
uint32_t mackey32[SHA_HMAC_KEY_SIZE/sizeof(uint32_t)] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
bool sha1 = false;
uint32_t auth_cfg = 0;
/* clear status */
writel_relaxed(0, pce_dev->iobase + CRYPTO_STATUS_REG);
writel_relaxed(pce_dev->reg.crypto_cfg_be, (pce_dev->iobase +
CRYPTO_CONFIG_REG));
/*
* Ensure previous instructions (setting the CONFIG register)
* was completed before issuing starting to set other config register
* This is to ensure the configurations are done in correct endian-ness
* as set in the CONFIG registers
*/
mb();
if (sreq->alg == QCE_HASH_AES_CMAC) {
/* write seg_cfg */
writel_relaxed(0, pce_dev->iobase + <API key>);
/* write seg_cfg */
writel_relaxed(0, pce_dev->iobase + <API key>);
/* write seg_cfg */
writel_relaxed(0, pce_dev->iobase + <API key>);
/* Clear auth_ivn, auth_keyn registers */
for (i = 0; i < 16; i++) {
writel_relaxed(0, (pce_dev->iobase +
(CRYPTO_AUTH_IV0_REG + i*sizeof(uint32_t))));
writel_relaxed(0, (pce_dev->iobase +
(<API key> + i*sizeof(uint32_t))));
}
/* write auth_bytecnt 0/1/2/3, start with 0 */
for (i = 0; i < 4; i++)
writel_relaxed(0, pce_dev->iobase +
<API key> +
i * sizeof(uint32_t));
if (sreq->authklen == AES128_KEY_SIZE)
auth_cfg = pce_dev->reg.auth_cfg_cmac_128;
else
auth_cfg = pce_dev->reg.auth_cfg_cmac_256;
}
if ((sreq->alg == QCE_HASH_SHA1_HMAC) ||
(sreq->alg == <API key>) ||
(sreq->alg == QCE_HASH_AES_CMAC)) {
uint32_t authk_size_in_word = sreq->authklen/sizeof(uint32_t);
<API key>(mackey32, sreq->authkey,
sreq->authklen);
/* check for null key. If null, use hw key*/
for (i = 0; i < authk_size_in_word; i++) {
if (mackey32[i] != 0)
break;
}
if (i == authk_size_in_word)
use_hw_key = true;
else
/* Clear auth_ivn, auth_keyn registers */
for (i = 0; i < authk_size_in_word; i++)
writel_relaxed(mackey32[i], (pce_dev->iobase +
(<API key> +
i*sizeof(uint32_t))));
}
if (sreq->alg == QCE_HASH_AES_CMAC)
goto go_proc;
/* if not the last, the size has to be on the block boundary */
if (sreq->last_blk == 0 && (sreq->size % SHA256_BLOCK_SIZE))
return -EIO;
switch (sreq->alg) {
case QCE_HASH_SHA1:
auth_cfg = pce_dev->reg.auth_cfg_sha1;
diglen = SHA1_DIGEST_SIZE;
sha1 = true;
break;
case QCE_HASH_SHA1_HMAC:
auth_cfg = pce_dev->reg.auth_cfg_hmac_sha1;
diglen = SHA1_DIGEST_SIZE;
sha1 = true;
break;
case QCE_HASH_SHA256:
auth_cfg = pce_dev->reg.auth_cfg_sha256;
diglen = SHA256_DIGEST_SIZE;
break;
case <API key>:
auth_cfg = pce_dev->reg.<API key>;
diglen = SHA256_DIGEST_SIZE;
break;
default:
return -EINVAL;
}
/* write 20/32 bytes, 5/8 words into auth_iv for SHA1/SHA256 */
if (sreq->first_blk) {
if (sha1) {
for (i = 0; i < 5; i++)
auth32[i] = <API key>[i];
} else {
for (i = 0; i < 8; i++)
auth32[i] = <API key>[i];
}
} else {
<API key>(auth32, sreq->digest, diglen);
}
/* Set auth_ivn, auth_keyn registers */
for (i = 0; i < 5; i++)
writel_relaxed(auth32[i], (pce_dev->iobase +
(CRYPTO_AUTH_IV0_REG + i*sizeof(uint32_t))));
if ((sreq->alg == QCE_HASH_SHA256) ||
(sreq->alg == <API key>)) {
for (i = 5; i < 8; i++)
writel_relaxed(auth32[i], (pce_dev->iobase +
(CRYPTO_AUTH_IV0_REG + i*sizeof(uint32_t))));
}
/* write auth_bytecnt 0/1/2/3, start with 0 */
for (i = 0; i < 2; i++)
writel_relaxed(sreq->auth_data[i], pce_dev->iobase +
<API key> +
i * sizeof(uint32_t));
/* Set/reset last bit in CFG register */
if (sreq->last_blk)
auth_cfg |= 1 << CRYPTO_LAST;
else
auth_cfg &= ~(1 << CRYPTO_LAST);
if (sreq->first_blk)
auth_cfg |= 1 << CRYPTO_FIRST;
else
auth_cfg &= ~(1 << CRYPTO_FIRST);
go_proc:
/* write seg_cfg */
writel_relaxed(auth_cfg, pce_dev->iobase + <API key>);
/* write auth seg_size */
writel_relaxed(sreq->size, pce_dev->iobase + <API key>);
/* write auth_seg_start */
writel_relaxed(0, pce_dev->iobase + <API key>);
/* reset encr seg_cfg */
writel_relaxed(0, pce_dev->iobase + <API key>);
/* write seg_size */
writel_relaxed(sreq->size, pce_dev->iobase + CRYPTO_SEG_SIZE_REG);
writel_relaxed(pce_dev->reg.crypto_cfg_le, (pce_dev->iobase +
CRYPTO_CONFIG_REG));
/* issue go to crypto */
if (use_hw_key == false)
writel_relaxed(((1 << CRYPTO_GO) | (1 << CRYPTO_RESULTS_DUMP)),
pce_dev->iobase + CRYPTO_GOPROC_REG);
else
writel_relaxed(((1 << CRYPTO_GO) | (1 << CRYPTO_RESULTS_DUMP)),
pce_dev->iobase + <API key>);
/*
* Ensure previous instructions (setting the GO register)
* was completed before issuing a DMA transfer request
*/
mb();
return 0;
}
static int <API key>(struct qce_device *pce_dev,
struct qce_req *q_req, uint32_t totallen_in, uint32_t coffset)
{
int32_t authk_size_in_word = q_req->authklen/sizeof(uint32_t);
int i;
uint32_t mackey32[SHA_HMAC_KEY_SIZE/sizeof(uint32_t)] = {0};
uint32_t a_cfg;
uint32_t enckey32[(MAX_CIPHER_KEY_SIZE*2)/sizeof(uint32_t)] = {0};
uint32_t enciv32[MAX_IV_LENGTH/sizeof(uint32_t)] = {0};
uint32_t enck_size_in_word = 0;
uint32_t enciv_in_word;
uint32_t key_size;
uint32_t ivsize = q_req->ivsize;
uint32_t encr_cfg;
/* clear status */
writel_relaxed(0, pce_dev->iobase + CRYPTO_STATUS_REG);
writel_relaxed(pce_dev->reg.crypto_cfg_be, (pce_dev->iobase +
CRYPTO_CONFIG_REG));
/*
* Ensure previous instructions (setting the CONFIG register)
* was completed before issuing starting to set other config register
* This is to ensure the configurations are done in correct endian-ness
* as set in the CONFIG registers
*/
mb();
key_size = q_req->encklen;
enck_size_in_word = key_size/sizeof(uint32_t);
switch (q_req->alg) {
case CIPHER_ALG_DES:
switch (q_req->mode) {
case QCE_MODE_ECB:
encr_cfg = pce_dev->reg.encr_cfg_des_ecb;
break;
case QCE_MODE_CBC:
encr_cfg = pce_dev->reg.encr_cfg_des_cbc;
break;
default:
return -EINVAL;
}
enciv_in_word = 2;
break;
case CIPHER_ALG_3DES:
switch (q_req->mode) {
case QCE_MODE_ECB:
encr_cfg = pce_dev->reg.encr_cfg_3des_ecb;
break;
case QCE_MODE_CBC:
encr_cfg = pce_dev->reg.encr_cfg_3des_cbc;
break;
default:
return -EINVAL;
}
enciv_in_word = 2;
break;
case CIPHER_ALG_AES:
switch (q_req->mode) {
case QCE_MODE_ECB:
if (key_size == AES128_KEY_SIZE)
encr_cfg = pce_dev->reg.<API key>;
else if (key_size == AES256_KEY_SIZE)
encr_cfg = pce_dev->reg.<API key>;
else
return -EINVAL;
break;
case QCE_MODE_CBC:
if (key_size == AES128_KEY_SIZE)
encr_cfg = pce_dev->reg.<API key>;
else if (key_size == AES256_KEY_SIZE)
encr_cfg = pce_dev->reg.<API key>;
else
return -EINVAL;
break;
default:
return -EINVAL;
}
enciv_in_word = 4;
break;
default:
return -EINVAL;
}
pce_dev->mode = q_req->mode;
/* write CNTR0_IV0_REG */
if (q_req->mode != QCE_MODE_ECB) {
<API key>(enciv32, q_req->iv, ivsize);
for (i = 0; i < enciv_in_word; i++)
writel_relaxed(enciv32[i], pce_dev->iobase +
(<API key> + i * sizeof(uint32_t)));
}
/*
* write encr key
* do not use hw key or pipe key
*/
<API key>(enckey32, q_req->enckey, key_size);
for (i = 0; i < enck_size_in_word; i++)
writel_relaxed(enckey32[i], pce_dev->iobase +
(<API key> + i * sizeof(uint32_t)));
/* write encr seg cfg */
if (q_req->dir == QCE_ENCRYPT)
encr_cfg |= (1 << CRYPTO_ENCODE);
writel_relaxed(encr_cfg, pce_dev->iobase + <API key>);
/* we only support sha1-hmac at this point */
<API key>(mackey32, q_req->authkey,
q_req->authklen);
for (i = 0; i < authk_size_in_word; i++)
writel_relaxed(mackey32[i], pce_dev->iobase +
(<API key> + i * sizeof(uint32_t)));
for (i = 0; i < 5; i++)
writel_relaxed(<API key>[i], pce_dev->iobase +
(CRYPTO_AUTH_IV0_REG + i * sizeof(uint32_t)));
/* write auth_bytecnt 0/1, start with 0 */
writel_relaxed(0, pce_dev->iobase + <API key>);
writel_relaxed(0, pce_dev->iobase + <API key>);
/* write encr seg size */
writel_relaxed(q_req->cryptlen, pce_dev->iobase +
<API key>);
/* write encr start */
writel_relaxed(coffset & 0xffff, pce_dev->iobase +
<API key>);
a_cfg = (<API key> << CRYPTO_AUTH_MODE) |
(<API key> << CRYPTO_AUTH_SIZE) |
(1 << CRYPTO_LAST) | (1 << CRYPTO_FIRST) |
(CRYPTO_AUTH_ALG_SHA << CRYPTO_AUTH_ALG);
if (q_req->dir == QCE_ENCRYPT)
a_cfg |= (<API key> << CRYPTO_AUTH_POS);
else
a_cfg |= (<API key> << CRYPTO_AUTH_POS);
/* write auth seg_cfg */
writel_relaxed(a_cfg, pce_dev->iobase + <API key>);
/* write auth seg_size */
writel_relaxed(totallen_in, pce_dev->iobase + <API key>);
/* write auth_seg_start */
writel_relaxed(0, pce_dev->iobase + <API key>);
/* write seg_size */
writel_relaxed(totallen_in, pce_dev->iobase + CRYPTO_SEG_SIZE_REG);
writel_relaxed(pce_dev->reg.crypto_cfg_le, (pce_dev->iobase +
CRYPTO_CONFIG_REG));
/* issue go to crypto */
writel_relaxed(((1 << CRYPTO_GO) | (1 << CRYPTO_RESULTS_DUMP)),
pce_dev->iobase + CRYPTO_GOPROC_REG);
/*
* Ensure previous instructions (setting the GO register)
* was completed before issuing a DMA transfer request
*/
mb();
return 0;
};
static int <API key>(struct qce_device *pce_dev,
struct qce_req *creq, uint32_t totallen_in, uint32_t coffset)
{
uint32_t enckey32[(MAX_CIPHER_KEY_SIZE * 2)/sizeof(uint32_t)] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
uint32_t enciv32[MAX_IV_LENGTH / sizeof(uint32_t)] = {
0, 0, 0, 0};
uint32_t enck_size_in_word = 0;
uint32_t key_size;
bool use_hw_key = false;
bool use_pipe_key = false;
uint32_t encr_cfg = 0;
uint32_t ivsize = creq->ivsize;
int i;
/* clear status */
writel_relaxed(0, pce_dev->iobase + CRYPTO_STATUS_REG);
writel_relaxed(pce_dev->reg.crypto_cfg_be, (pce_dev->iobase +
CRYPTO_CONFIG_REG));
/*
* Ensure previous instructions (setting the CONFIG register)
* was completed before issuing starting to set other config register
* This is to ensure the configurations are done in correct endian-ness
* as set in the CONFIG registers
*/
mb();
if (creq->mode == QCE_MODE_XTS)
key_size = creq->encklen/2;
else
key_size = creq->encklen;
if ((creq->flags & <API key>) == <API key>) {
use_hw_key = true;
} else {
if ((creq->flags & <API key>) ==
<API key>)
use_pipe_key = true;
}
if ((use_pipe_key == false) && (use_hw_key == false)) {
<API key>(enckey32, creq->enckey, key_size);
enck_size_in_word = key_size/sizeof(uint32_t);
}
if ((creq->op == QCE_REQ_AEAD) && (creq->mode == QCE_MODE_CCM)) {
uint32_t authklen32 = creq->encklen/sizeof(uint32_t);
uint32_t noncelen32 = MAX_NONCE/sizeof(uint32_t);
uint32_t nonce32[MAX_NONCE/sizeof(uint32_t)] = {0, 0, 0, 0};
uint32_t auth_cfg = 0;
/* Clear auth_ivn, auth_keyn registers */
for (i = 0; i < 16; i++) {
writel_relaxed(0, (pce_dev->iobase +
(CRYPTO_AUTH_IV0_REG + i*sizeof(uint32_t))));
writel_relaxed(0, (pce_dev->iobase +
(<API key> + i*sizeof(uint32_t))));
}
/* write auth_bytecnt 0/1/2/3, start with 0 */
for (i = 0; i < 4; i++)
writel_relaxed(0, pce_dev->iobase +
<API key> +
i * sizeof(uint32_t));
/* write nonce */
<API key>(nonce32, creq->nonce, MAX_NONCE);
for (i = 0; i < noncelen32; i++)
writel_relaxed(nonce32[i], pce_dev->iobase +
CRYPTO_<API key> +
(i*sizeof(uint32_t)));
if (creq->authklen == AES128_KEY_SIZE)
auth_cfg = pce_dev->reg.<API key>;
else {
if (creq->authklen == AES256_KEY_SIZE)
auth_cfg = pce_dev->reg.<API key>;
}
if (creq->dir == QCE_ENCRYPT)
auth_cfg |= (<API key> << CRYPTO_AUTH_POS);
else
auth_cfg |= (<API key> << CRYPTO_AUTH_POS);
auth_cfg |= ((creq->authsize - 1) << CRYPTO_AUTH_SIZE);
if (use_hw_key == true) {
auth_cfg |= (1 << <API key>);
} else {
auth_cfg &= ~(1 << <API key>);
/* write auth key */
for (i = 0; i < authklen32; i++)
writel_relaxed(enckey32[i], pce_dev->iobase +
<API key> + (i*sizeof(uint32_t)));
}
writel_relaxed(auth_cfg, pce_dev->iobase +
<API key>);
if (creq->dir == QCE_ENCRYPT)
writel_relaxed(totallen_in, pce_dev->iobase +
<API key>);
else
writel_relaxed((totallen_in - creq->authsize),
pce_dev->iobase + <API key>);
writel_relaxed(0, pce_dev->iobase + <API key>);
} else {
if (creq->op != QCE_REQ_AEAD)
writel_relaxed(0, pce_dev->iobase +
<API key>);
}
/*
* Ensure previous instructions (write to all AUTH registers)
* was completed before accessing a register that is not in
* in the same 1K range.
*/
mb();
switch (creq->mode) {
case QCE_MODE_ECB:
if (key_size == AES128_KEY_SIZE)
encr_cfg = pce_dev->reg.<API key>;
else
encr_cfg = pce_dev->reg.<API key>;
break;
case QCE_MODE_CBC:
if (key_size == AES128_KEY_SIZE)
encr_cfg = pce_dev->reg.<API key>;
else
encr_cfg = pce_dev->reg.<API key>;
break;
case QCE_MODE_XTS:
if (key_size == AES128_KEY_SIZE)
encr_cfg = pce_dev->reg.<API key>;
else
encr_cfg = pce_dev->reg.<API key>;
break;
case QCE_MODE_CCM:
if (key_size == AES128_KEY_SIZE)
encr_cfg = pce_dev->reg.<API key>;
else
encr_cfg = pce_dev->reg.<API key>;
break;
case QCE_MODE_CTR:
default:
if (key_size == AES128_KEY_SIZE)
encr_cfg = pce_dev->reg.<API key>;
else
encr_cfg = pce_dev->reg.<API key>;
break;
}
pce_dev->mode = creq->mode;
switch (creq->alg) {
case CIPHER_ALG_DES:
if (creq->mode != QCE_MODE_ECB) {
encr_cfg = pce_dev->reg.encr_cfg_des_cbc;
<API key>(enciv32, creq->iv, ivsize);
writel_relaxed(enciv32[0], pce_dev->iobase +
<API key>);
writel_relaxed(enciv32[1], pce_dev->iobase +
<API key>);
} else {
encr_cfg = pce_dev->reg.encr_cfg_des_ecb;
}
if (use_hw_key == false) {
writel_relaxed(enckey32[0], pce_dev->iobase +
<API key>);
writel_relaxed(enckey32[1], pce_dev->iobase +
<API key>);
}
break;
case CIPHER_ALG_3DES:
if (creq->mode != QCE_MODE_ECB) {
<API key>(enciv32, creq->iv, ivsize);
writel_relaxed(enciv32[0], pce_dev->iobase +
<API key>);
writel_relaxed(enciv32[1], pce_dev->iobase +
<API key>);
encr_cfg = pce_dev->reg.encr_cfg_3des_cbc;
} else {
encr_cfg = pce_dev->reg.encr_cfg_3des_ecb;
}
if (use_hw_key == false) {
/* write encr key */
for (i = 0; i < 6; i++)
writel_relaxed(enckey32[0], (pce_dev->iobase +
(<API key> + i * sizeof(uint32_t))));
}
break;
case CIPHER_ALG_AES:
default:
if (creq->mode == QCE_MODE_XTS) {
uint32_t xtskey32[MAX_CIPHER_KEY_SIZE/sizeof(uint32_t)]
= {0, 0, 0, 0, 0, 0, 0, 0};
uint32_t xtsklen =
creq->encklen/(2 * sizeof(uint32_t));
if ((use_hw_key == false) && (use_pipe_key == false)) {
<API key>(xtskey32,
(creq->enckey + creq->encklen/2),
creq->encklen/2);
/* write xts encr key */
for (i = 0; i < xtsklen; i++)
writel_relaxed(xtskey32[i],
pce_dev->iobase +
<API key> +
(i * sizeof(uint32_t)));
}
/* write xts du size */
if (use_pipe_key == true)
writel_relaxed(min((uint32_t)QCE_SECTOR_SIZE,
creq->cryptlen),
pce_dev->iobase +
<API key>);
else
writel_relaxed(creq->cryptlen ,
pce_dev->iobase +
<API key>);
}
if (creq->mode != QCE_MODE_ECB) {
if (creq->mode == QCE_MODE_XTS)
<API key>(enciv32,
creq->iv, ivsize);
else
<API key>(enciv32, creq->iv,
ivsize);
/* write encr cntr iv */
for (i = 0; i <= 3; i++)
writel_relaxed(enciv32[i], pce_dev->iobase +
<API key> +
(i * sizeof(uint32_t)));
if (creq->mode == QCE_MODE_CCM) {
/* write cntr iv for ccm */
for (i = 0; i <= 3; i++)
writel_relaxed(enciv32[i],
pce_dev->iobase +
<API key> +
(i * sizeof(uint32_t)));
/* update cntr_iv[3] by one */
writel_relaxed((enciv32[3] + 1),
pce_dev->iobase +
<API key> +
(3 * sizeof(uint32_t)));
}
}
if (creq->op == <API key>) {
encr_cfg |= (<API key> <<
CRYPTO_ENCR_KEY_SZ);
} else {
if ((use_hw_key == false) && (use_pipe_key == false)) {
for (i = 0; i < enck_size_in_word; i++)
writel_relaxed(enckey32[i],
pce_dev->iobase +
<API key> +
(i * sizeof(uint32_t)));
}
} /* else of if (creq->op == <API key>) */
break;
} /* end of switch (creq->mode) */
if (use_pipe_key)
encr_cfg |= (<API key>
<< <API key>);
/* write encr seg cfg */
encr_cfg |= ((creq->dir == QCE_ENCRYPT) ? 1 : 0) << CRYPTO_ENCODE;
if (use_hw_key == true)
encr_cfg |= (CRYPTO_USE_HW_KEY << <API key>);
else
encr_cfg &= ~(CRYPTO_USE_HW_KEY << <API key>);
/* write encr seg cfg */
writel_relaxed(encr_cfg, pce_dev->iobase + <API key>);
/* write encr seg size */
if ((creq->mode == QCE_MODE_CCM) && (creq->dir == QCE_DECRYPT))
writel_relaxed((creq->cryptlen + creq->authsize),
pce_dev->iobase + <API key>);
else
writel_relaxed(creq->cryptlen,
pce_dev->iobase + <API key>);
/* write encr seg start */
writel_relaxed((coffset & 0xffff),
pce_dev->iobase + <API key>);
/* write encr seg start */
writel_relaxed(0xffffffff,
pce_dev->iobase + <API key>);
/* write seg size */
writel_relaxed(totallen_in, pce_dev->iobase + CRYPTO_SEG_SIZE_REG);
writel_relaxed(pce_dev->reg.crypto_cfg_le, (pce_dev->iobase +
CRYPTO_CONFIG_REG));
/* issue go to crypto */
if (use_hw_key == false)
writel_relaxed(((1 << CRYPTO_GO) | (1 << CRYPTO_RESULTS_DUMP)),
pce_dev->iobase + CRYPTO_GOPROC_REG);
else
writel_relaxed(((1 << CRYPTO_GO) | (1 << CRYPTO_RESULTS_DUMP)),
pce_dev->iobase + <API key>);
/*
* Ensure previous instructions (setting the GO register)
* was completed before issuing a DMA transfer request
*/
mb();
return 0;
};
static int <API key>(struct qce_device *pce_dev)
{
int rc = 0;
if (pce_dev->support_cmd_dscr == false)
return rc;
pce_dev->ce_sps.consumer.event.callback = NULL;
rc = sps_transfer_one(pce_dev->ce_sps.consumer.pipe,
GET_PHYS_ADDR(pce_dev->ce_sps.cmdlistptr.unlock_all_pipes.cmdlist),
0, NULL, (SPS_IOVEC_FLAG_CMD | <API key>));
if (rc) {
pr_err("sps_xfr_one() fail rc=%d", rc);
rc = -EINVAL;
}
return rc;
}
static int _aead_complete(struct qce_device *pce_dev)
{
struct aead_request *areq;
unsigned char mac[SHA256_DIGEST_SIZE];
uint32_t status;
int32_t result_status;
areq = (struct aead_request *) pce_dev->areq;
if (areq->src != areq->dst) {
qce_dma_unmap_sg(pce_dev->pdev, areq->dst, pce_dev->dst_nents,
DMA_FROM_DEVICE);
}
qce_dma_unmap_sg(pce_dev->pdev, areq->src, pce_dev->src_nents,
(areq->src == areq->dst) ? DMA_BIDIRECTIONAL :
DMA_TO_DEVICE);
qce_dma_unmap_sg(pce_dev->pdev, areq->assoc, pce_dev->assoc_nents,
DMA_TO_DEVICE);
/* check MAC */
memcpy(mac, (char *)(&pce_dev->ce_sps.result->auth_iv[0]),
SHA256_DIGEST_SIZE);
/* read status before unlock */
status = readl_relaxed(pce_dev->iobase + CRYPTO_STATUS_REG);
if (<API key>(pce_dev))
return -EINVAL;
/*
* Don't use result dump status. The operation may not
* be complete.
* Instead, use the status we just read of device.
* In case, we need to use result_status from result
* dump the result_status needs to be byte swapped,
* since we set the device to little endian.
*/
result_status = 0;
pce_dev->ce_sps.result->status = 0;
if (status & ((1 << CRYPTO_SW_ERR) | (1 << CRYPTO_AXI_ERR)
| (1 << CRYPTO_HSD_ERR))) {
pr_err("aead operation error. Status %x\n", status);
result_status = -ENXIO;
} else if (pce_dev->ce_sps.consumer_status |
pce_dev->ce_sps.producer_status) {
pr_err("aead sps operation error. sps status %x %x\n",
pce_dev->ce_sps.consumer_status,
pce_dev->ce_sps.producer_status);
result_status = -ENXIO;
} else if ((status & (1 << <API key>)) == 0) {
pr_err("aead operation not done? Status %x, sps status %x %x\n",
status,
pce_dev->ce_sps.consumer_status,
pce_dev->ce_sps.producer_status);
result_status = -ENXIO;
}
if (pce_dev->mode == QCE_MODE_CCM) {
if (result_status == 0 && (status & (1 << CRYPTO_MAC_FAILED)))
result_status = -EBADMSG;
pce_dev->qce_cb(areq, mac, NULL, result_status);
} else {
uint32_t ivsize = 0;
struct crypto_aead *aead;
unsigned char iv[<API key> * CRYPTO_REG_SIZE];
aead = crypto_aead_reqtfm(areq);
ivsize = crypto_aead_ivsize(aead);
if (pce_dev->ce_sps.minor_version != 0)
dma_unmap_single(pce_dev->pdev, pce_dev->phy_iv_in,
ivsize, DMA_TO_DEVICE);
memcpy(iv, (char *)(pce_dev->ce_sps.result->encr_cntr_iv),
sizeof(iv));
pce_dev->qce_cb(areq, mac, iv, result_status);
}
return 0;
};
static int _sha_complete(struct qce_device *pce_dev)
{
struct ahash_request *areq;
unsigned char digest[SHA256_DIGEST_SIZE];
uint32_t bytecount32[2];
int32_t result_status = pce_dev->ce_sps.result->status;
uint32_t status;
areq = (struct ahash_request *) pce_dev->areq;
qce_dma_unmap_sg(pce_dev->pdev, areq->src, pce_dev->src_nents,
DMA_TO_DEVICE);
memcpy(digest, (char *)(&pce_dev->ce_sps.result->auth_iv[0]),
SHA256_DIGEST_SIZE);
<API key>(bytecount32,
(unsigned char *)pce_dev->ce_sps.result->auth_byte_count,
2 * CRYPTO_REG_SIZE);
/* read status before unlock */
status = readl_relaxed(pce_dev->iobase + CRYPTO_STATUS_REG);
if (<API key>(pce_dev))
return -EINVAL;
/*
* Don't use result dump status. The operation may not be complete.
* Instead, use the status we just read of device.
* In case, we need to use result_status from result
* dump the result_status needs to be byte swapped,
* since we set the device to little endian.
*/
if (status & ((1 << CRYPTO_SW_ERR) | (1 << CRYPTO_AXI_ERR)
| (1 << CRYPTO_HSD_ERR))) {
pr_err("sha operation error. Status %x\n", status);
result_status = -ENXIO;
} else if (pce_dev->ce_sps.consumer_status) {
pr_err("sha sps operation error. sps status %x\n",
pce_dev->ce_sps.consumer_status);
result_status = -ENXIO;
} else if ((status & (1 << <API key>)) == 0) {
pr_err("sha operation not done? Status %x, sps status %x\n",
status, pce_dev->ce_sps.consumer_status);
result_status = -ENXIO;
} else {
result_status = 0;
}
pce_dev->qce_cb(areq, digest, (char *)bytecount32,
result_status);
return 0;
};
static int <API key>(struct qce_device *pce_dev)
{
struct ablkcipher_request *areq;
unsigned char iv[<API key> * CRYPTO_REG_SIZE];
uint32_t status;
int32_t result_status;
areq = (struct ablkcipher_request *) pce_dev->areq;
if (areq->src != areq->dst) {
qce_dma_unmap_sg(pce_dev->pdev, areq->dst,
pce_dev->dst_nents, DMA_FROM_DEVICE);
}
qce_dma_unmap_sg(pce_dev->pdev, areq->src, pce_dev->src_nents,
(areq->src == areq->dst) ? DMA_BIDIRECTIONAL :
DMA_TO_DEVICE);
/* read status before unlock */
status = readl_relaxed(pce_dev->iobase + CRYPTO_STATUS_REG);
if (<API key>(pce_dev))
return -EINVAL;
/*
* Don't use result dump status. The operation may not be complete.
* Instead, use the status we just read of device.
* In case, we need to use result_status from result
* dump the result_status needs to be byte swapped,
* since we set the device to little endian.
*/
if (status & ((1 << CRYPTO_SW_ERR) | (1 << CRYPTO_AXI_ERR)
| (1 << CRYPTO_HSD_ERR))) {
pr_err("ablk_cipher operation error. Status %x\n",
status);
result_status = -ENXIO;
} else if (pce_dev->ce_sps.consumer_status |
pce_dev->ce_sps.producer_status) {
pr_err("ablk_cipher sps operation error. sps status %x %x\n",
pce_dev->ce_sps.consumer_status,
pce_dev->ce_sps.producer_status);
result_status = -ENXIO;
} else if ((status & (1 << <API key>)) == 0) {
pr_err("ablk_cipher operation not done? Status %x, sps status %x %x\n",
status,
pce_dev->ce_sps.consumer_status,
pce_dev->ce_sps.producer_status);
result_status = -ENXIO;
} else {
result_status = 0;
}
if (pce_dev->mode == QCE_MODE_ECB) {
pce_dev->qce_cb(areq, NULL, NULL,
pce_dev->ce_sps.consumer_status |
result_status);
} else {
if (pce_dev->ce_sps.minor_version == 0) {
if (pce_dev->mode == QCE_MODE_CBC) {
if (pce_dev->dir == QCE_DECRYPT)
memcpy(iv, (char *)pce_dev->dec_iv,
sizeof(iv));
else
memcpy(iv, (unsigned char *)
(sg_virt(areq->src) +
areq->src->length - 16),
sizeof(iv));
}
if ((pce_dev->mode == QCE_MODE_CTR) ||
(pce_dev->mode == QCE_MODE_XTS)) {
uint32_t num_blk = 0;
uint32_t cntr_iv3 = 0;
unsigned long long cntr_iv64 = 0;
unsigned char *b = (unsigned char *)(&cntr_iv3);
memcpy(iv, areq->info, sizeof(iv));
if (pce_dev->mode != QCE_MODE_XTS)
num_blk = areq->nbytes/16;
else
num_blk = 1;
cntr_iv3 = ((*(iv + 12) << 24) & 0xff000000) |
(((*(iv + 13)) << 16) & 0xff0000) |
(((*(iv + 14)) << 8) & 0xff00) |
(*(iv + 15) & 0xff);
cntr_iv64 =
(((unsigned long long)cntr_iv3 &
(unsigned long long)0xFFFFFFFFULL) +
(unsigned long long)num_blk) %
(unsigned long long)(0x100000000ULL);
cntr_iv3 = (u32)(cntr_iv64 & 0xFFFFFFFF);
*(iv + 15) = (char)(*b);
*(iv + 14) = (char)(*(b + 1));
*(iv + 13) = (char)(*(b + 2));
*(iv + 12) = (char)(*(b + 3));
}
} else {
memcpy(iv,
(char *)(pce_dev->ce_sps.result->encr_cntr_iv),
sizeof(iv));
}
pce_dev->qce_cb(areq, NULL, iv, result_status);
}
return 0;
};
#ifdef QCE_DEBUG
static void <API key>(struct qce_device *pce_dev)
{
int i, j, ents;
struct sps_iovec *iovec = pce_dev->ce_sps.in_transfer.iovec;
uint32_t cmd_flags = SPS_IOVEC_FLAG_CMD;
printk(KERN_INFO "==============================================\n");
printk(KERN_INFO "CONSUMER (TX/IN/DEST) PIPE DESCRIPTOR\n");
printk(KERN_INFO "==============================================\n");
for (i = 0; i < pce_dev->ce_sps.in_transfer.iovec_count; i++) {
printk(KERN_INFO " [%d] addr=0x%x size=0x%x flags=0x%x\n", i,
iovec->addr, iovec->size, iovec->flags);
if (iovec->flags & cmd_flags) {
struct sps_command_element *pced;
pced = (struct sps_command_element *)
(GET_VIRT_ADDR(iovec->addr));
ents = iovec->size/(sizeof(struct sps_command_element));
for (j = 0; j < ents; j++) {
printk(KERN_INFO " [%d] [0x%x] 0x%x\n", j,
pced->addr, pced->data);
pced++;
}
}
iovec++;
}
printk(KERN_INFO "==============================================\n");
printk(KERN_INFO "PRODUCER (RX/OUT/SRC) PIPE DESCRIPTOR\n");
printk(KERN_INFO "==============================================\n");
iovec = pce_dev->ce_sps.out_transfer.iovec;
for (i = 0; i < pce_dev->ce_sps.out_transfer.iovec_count; i++) {
printk(KERN_INFO " [%d] addr=0x%x size=0x%x flags=0x%x\n", i,
iovec->addr, iovec->size, iovec->flags);
iovec++;
}
}
#else
static void <API key>(struct qce_device *pce_dev)
{
}
#endif
static void <API key>(struct qce_device *pce_dev)
{
int i, j, ents;
struct sps_iovec *iovec = pce_dev->ce_sps.in_transfer.iovec;
uint32_t cmd_flags = SPS_IOVEC_FLAG_CMD;
printk(KERN_INFO "==============================================\n");
printk(KERN_INFO "CONSUMER (TX/IN/DEST) PIPE DESCRIPTOR\n");
printk(KERN_INFO "==============================================\n");
for (i = 0; i < pce_dev->ce_sps.in_transfer.iovec_count; i++) {
printk(KERN_INFO " [%d] addr=0x%x size=0x%x flags=0x%x\n", i,
iovec->addr, iovec->size, iovec->flags);
if (iovec->flags & cmd_flags) {
struct sps_command_element *pced;
pced = (struct sps_command_element *)
(GET_VIRT_ADDR(iovec->addr));
ents = iovec->size/(sizeof(struct sps_command_element));
for (j = 0; j < ents; j++) {
printk(KERN_INFO " [%d] [0x%x] 0x%x\n", j,
pced->addr, pced->data);
pced++;
}
}
iovec++;
}
printk(KERN_INFO "==============================================\n");
printk(KERN_INFO "PRODUCER (RX/OUT/SRC) PIPE DESCRIPTOR\n");
printk(KERN_INFO "==============================================\n");
iovec = pce_dev->ce_sps.out_transfer.iovec;
for (i = 0; i < pce_dev->ce_sps.out_transfer.iovec_count; i++) {
printk(KERN_INFO " [%d] addr=0x%x size=0x%x flags=0x%x\n", i,
iovec->addr, iovec->size, iovec->flags);
iovec++;
}
}
static void <API key>(struct qce_device *pce_dev)
{
pce_dev->ce_sps.in_transfer.iovec_count = 0;
pce_dev->ce_sps.out_transfer.iovec_count = 0;
}
static void _qce_set_flag(struct sps_transfer *sps_bam_pipe, uint32_t flag)
{
struct sps_iovec *iovec = sps_bam_pipe->iovec +
(sps_bam_pipe->iovec_count - 1);
iovec->flags |= flag;
}
static int _qce_sps_add_data(uint32_t addr, uint32_t len,
struct sps_transfer *sps_bam_pipe)
{
struct sps_iovec *iovec = sps_bam_pipe->iovec +
sps_bam_pipe->iovec_count;
if (sps_bam_pipe->iovec_count == QCE_MAX_NUM_DSCR) {
pr_err("Num of descrptor %d exceed max (%d)",
sps_bam_pipe->iovec_count, (uint32_t)QCE_MAX_NUM_DSCR);
return -ENOMEM;
}
if (len) {
iovec->size = len;
iovec->addr = addr;
iovec->flags = 0;
sps_bam_pipe->iovec_count++;
}
return 0;
}
static int <API key>(struct qce_device *pce_dev,
struct scatterlist *sg_src, uint32_t nbytes,
struct sps_transfer *sps_bam_pipe)
{
uint32_t addr, data_cnt, len;
struct sps_iovec *iovec = sps_bam_pipe->iovec +
sps_bam_pipe->iovec_count;
while (nbytes > 0) {
len = min(nbytes, sg_dma_len(sg_src));
nbytes -= len;
addr = sg_dma_address(sg_src);
if (pce_dev->ce_sps.minor_version == 0)
len = ALIGN(len, pce_dev->ce_sps.ce_burst_size);
while (len > 0) {
if (sps_bam_pipe->iovec_count == QCE_MAX_NUM_DSCR) {
pr_err("Num of descrptor %d exceed max (%d)",
sps_bam_pipe->iovec_count,
(uint32_t)QCE_MAX_NUM_DSCR);
return -ENOMEM;
}
if (len > SPS_MAX_PKT_SIZE) {
data_cnt = SPS_MAX_PKT_SIZE;
iovec->size = data_cnt;
iovec->addr = addr;
iovec->flags = 0;
} else {
data_cnt = len;
iovec->size = data_cnt;
iovec->addr = addr;
iovec->flags = 0;
}
iovec++;
sps_bam_pipe->iovec_count++;
addr += data_cnt;
len -= data_cnt;
}
sg_src = scatterwalk_sg_next(sg_src);
}
return 0;
}
static int _qce_sps_add_cmd(struct qce_device *pce_dev, uint32_t flag,
struct qce_cmdlist_info *cmdptr,
struct sps_transfer *sps_bam_pipe)
{
struct sps_iovec *iovec = sps_bam_pipe->iovec +
sps_bam_pipe->iovec_count;
iovec->size = cmdptr->size;
iovec->addr = GET_PHYS_ADDR(cmdptr->cmdlist);
iovec->flags = SPS_IOVEC_FLAG_CMD | flag;
sps_bam_pipe->iovec_count++;
return 0;
}
static int _qce_sps_transfer(struct qce_device *pce_dev)
{
int rc = 0;
<API key>(pce_dev);
rc = sps_transfer(pce_dev->ce_sps.consumer.pipe,
&pce_dev->ce_sps.in_transfer);
if (rc) {
pr_err("sps_xfr() fail (consumer pipe=0x%x) rc = %d,",
(u32)pce_dev->ce_sps.consumer.pipe, rc);
<API key>(pce_dev);
return rc;
}
rc = sps_transfer(pce_dev->ce_sps.producer.pipe,
&pce_dev->ce_sps.out_transfer);
if (rc) {
pr_err("sps_xfr() fail (producer pipe=0x%x) rc = %d,",
(u32)pce_dev->ce_sps.producer.pipe, rc);
return rc;
}
return rc;
}
/**
* Allocate and Connect a CE peripheral's SPS endpoint
*
* This function allocates endpoint context and
* connect it with memory endpoint by calling
* appropriate SPS driver APIs.
*
* Also registers a SPS callback function with
* SPS driver
*
* This function should only be called once typically
* during driver probe.
*
* @pce_dev - Pointer to qce_device structure
* @ep - Pointer to sps endpoint data structure
* @is_produce - 1 means Producer endpoint
* 0 means Consumer endpoint
*
* @return - 0 if successful else negative value.
*
*/
static int <API key>(struct qce_device *pce_dev,
struct <API key> *ep,
bool is_producer)
{
int rc = 0;
struct sps_pipe *sps_pipe_info;
struct sps_connect *sps_connect_info = &ep->connect;
struct sps_register_event *sps_event = &ep->event;
/* Allocate endpoint context */
sps_pipe_info = sps_alloc_endpoint();
if (!sps_pipe_info) {
pr_err("sps_alloc_endpoint() failed!!! is_producer=%d",
is_producer);
rc = -ENOMEM;
goto out;
}
/* Now save the sps pipe handle */
ep->pipe = sps_pipe_info;
/* Get default connection configuration for an endpoint */
rc = sps_get_config(sps_pipe_info, sps_connect_info);
if (rc) {
pr_err("sps_get_config() fail pipe_handle=0x%x, rc = %d\n",
(u32)sps_pipe_info, rc);
goto get_config_err;
}
/* Modify the default connection configuration */
if (is_producer) {
/*
* For CE producer transfer, source should be
* CE peripheral where as destination should
* be system memory.
*/
sps_connect_info->source = pce_dev->ce_sps.bam_handle;
sps_connect_info->destination = SPS_DEV_HANDLE_MEM;
/* Producer pipe will handle this connection */
sps_connect_info->mode = SPS_MODE_SRC;
sps_connect_info->options =
SPS_O_AUTO_ENABLE | SPS_O_DESC_DONE;
} else {
/* For CE consumer transfer, source should be
* system memory where as destination should
* CE peripheral
*/
sps_connect_info->source = SPS_DEV_HANDLE_MEM;
sps_connect_info->destination = pce_dev->ce_sps.bam_handle;
sps_connect_info->mode = SPS_MODE_DEST;
sps_connect_info->options =
SPS_O_AUTO_ENABLE | SPS_O_EOT;
}
/* Producer pipe index */
sps_connect_info->src_pipe_index = pce_dev->ce_sps.src_pipe_index;
/* Consumer pipe index */
sps_connect_info->dest_pipe_index = pce_dev->ce_sps.dest_pipe_index;
/* Set pipe group */
sps_connect_info->lock_group = pce_dev->ce_sps.pipe_pair_index;
sps_connect_info->event_thresh = 0x10;
/*
* Max. no of scatter/gather buffers that can
* be passed by block layer = 32 (NR_SG).
* Each BAM descritor needs 64 bits (8 bytes).
* One BAM descriptor is required per buffer transfer.
* So we would require total 256 (32 * 8) bytes of descriptor FIFO.
* But due to HW limitation we need to allocate atleast one extra
* descriptor memory (256 bytes + 8 bytes). But in order to be
* in power of 2, we are allocating 512 bytes of memory.
*/
sps_connect_info->desc.size = QCE_MAX_NUM_DSCR *
sizeof(struct sps_iovec);
sps_connect_info->desc.base = dma_alloc_coherent(pce_dev->pdev,
sps_connect_info->desc.size,
&sps_connect_info->desc.phys_base,
GFP_KERNEL);
if (sps_connect_info->desc.base == NULL) {
rc = -ENOMEM;
pr_err("Can not allocate coherent memory for sps data\n");
goto get_config_err;
}
memset(sps_connect_info->desc.base, 0x00, sps_connect_info->desc.size);
/* Establish connection between peripheral and memory endpoint */
rc = sps_connect(sps_pipe_info, sps_connect_info);
if (rc) {
pr_err("sps_connect() fail pipe_handle=0x%x, rc = %d\n",
(u32)sps_pipe_info, rc);
goto sps_connect_err;
}
sps_event->mode = <API key>;
if (is_producer)
sps_event->options = SPS_O_EOT | SPS_O_DESC_DONE;
else
sps_event->options = SPS_O_EOT;
sps_event->xfer_done = NULL;
sps_event->user = (void *)pce_dev;
pr_debug("success, %s : pipe_handle=0x%x, desc fifo base (phy) = 0x%x\n",
is_producer ? "PRODUCER(RX/OUT)" : "CONSUMER(TX/IN)",
(u32)sps_pipe_info, sps_connect_info->desc.phys_base);
goto out;
sps_connect_err:
dma_free_coherent(pce_dev->pdev,
sps_connect_info->desc.size,
sps_connect_info->desc.base,
sps_connect_info->desc.phys_base);
get_config_err:
sps_free_endpoint(sps_pipe_info);
out:
return rc;
}
/**
* Disconnect and Deallocate a CE peripheral's SPS endpoint
*
* This function disconnect endpoint and deallocates
* endpoint context.
*
* This function should only be called once typically
* during driver remove.
*
* @pce_dev - Pointer to qce_device structure
* @ep - Pointer to sps endpoint data structure
*
*/
static void <API key>(struct qce_device *pce_dev,
struct <API key> *ep)
{
struct sps_pipe *sps_pipe_info = ep->pipe;
struct sps_connect *sps_connect_info = &ep->connect;
sps_disconnect(sps_pipe_info);
dma_free_coherent(pce_dev->pdev,
sps_connect_info->desc.size,
sps_connect_info->desc.base,
sps_connect_info->desc.phys_base);
sps_free_endpoint(sps_pipe_info);
}
/**
* Initialize SPS HW connected with CE core
*
* This function register BAM HW resources with
* SPS driver and then initialize 2 SPS endpoints
*
* This function should only be called once typically
* during driver probe.
*
* @pce_dev - Pointer to qce_device structure
*
* @return - 0 if successful else negative value.
*
*/
static int qce_sps_init(struct qce_device *pce_dev)
{
int rc = 0;
struct sps_bam_props bam = {0};
bool register_bam = false;
bam.phys_addr = pce_dev->ce_sps.bam_mem;
bam.virt_addr = pce_dev->ce_sps.bam_iobase;
/*
* This event thresold value is only significant for BAM-to-BAM
* transfer. It's ignored for BAM-to-System mode transfer.
*/
bam.event_threshold = 0x10; /* Pipe event threshold */
/*
* This threshold controls when the BAM publish
* the descriptor size on the sideband interface.
* SPS HW will only be used when
* data transfer size > 64 bytes.
*/
bam.summing_threshold = 64;
/* SPS driver wll handle the crypto BAM IRQ */
bam.irq = (u32)pce_dev->ce_sps.bam_irq;
/*
* Set flag to indicate BAM global device control is managed
* remotely.
*/
if ((pce_dev->support_cmd_dscr == false) || (pce_dev->is_shared))
bam.manage = <API key>;
else
bam.manage = SPS_BAM_MGR_LOCAL;
bam.ee = 1;
pr_debug("bam physical base=0x%x\n", (u32)bam.phys_addr);
pr_debug("bam virtual base=0x%x\n", (u32)bam.virt_addr);
mutex_lock(&bam_register_cnt);
if (ce_bam_registered == false) {
bam_registry.handle = 0;
bam_registry.cnt = 0;
}
if ((bam_registry.handle == 0) && (bam_registry.cnt == 0)) {
/* Register CE Peripheral BAM device to SPS driver */
rc = <API key>(&bam, &bam_registry.handle);
if (rc) {
mutex_unlock(&bam_register_cnt);
pr_err("<API key>() failed! err=%d", rc);
return -EIO;
}
bam_registry.cnt++;
register_bam = true;
ce_bam_registered = true;
} else {
bam_registry.cnt++;
}
mutex_unlock(&bam_register_cnt);
pce_dev->ce_sps.bam_handle = bam_registry.handle;
pr_debug("BAM device registered. bam_handle=0x%x",
pce_dev->ce_sps.bam_handle);
rc = <API key>(pce_dev, &pce_dev->ce_sps.producer, true);
if (rc)
goto <API key>;
rc = <API key>(pce_dev, &pce_dev->ce_sps.consumer, false);
if (rc)
goto <API key>;
pce_dev->ce_sps.out_transfer.user = pce_dev->ce_sps.producer.pipe;
pce_dev->ce_sps.in_transfer.user = pce_dev->ce_sps.consumer.pipe;
pr_info(" Qualcomm MSM CE-BAM at 0x%016llx irq %d\n",
(unsigned long long)pce_dev->ce_sps.bam_mem,
(unsigned int)pce_dev->ce_sps.bam_irq);
return rc;
<API key>:
<API key>(pce_dev, &pce_dev->ce_sps.producer);
<API key>:
if (register_bam) {
mutex_lock(&bam_register_cnt);
<API key>(pce_dev->ce_sps.bam_handle);
ce_bam_registered = false;
bam_registry.handle = 0;
bam_registry.cnt = 0;
mutex_unlock(&bam_register_cnt);
}
return rc;
}
/**
* De-initialize SPS HW connected with CE core
*
* This function deinitialize SPS endpoints and then
* deregisters BAM resources from SPS driver.
*
* This function should only be called once typically
* during driver remove.
*
* @pce_dev - Pointer to qce_device structure
*
*/
static void qce_sps_exit(struct qce_device *pce_dev)
{
<API key>(pce_dev, &pce_dev->ce_sps.consumer);
<API key>(pce_dev, &pce_dev->ce_sps.producer);
mutex_lock(&bam_register_cnt);
if ((bam_registry.handle != 0) && (bam_registry.cnt == 1)) {
<API key>(pce_dev->ce_sps.bam_handle);
bam_registry.cnt = 0;
bam_registry.handle = 0;
}
if ((bam_registry.handle != 0) && (bam_registry.cnt > 1))
bam_registry.cnt
mutex_unlock(&bam_register_cnt);
iounmap(pce_dev->ce_sps.bam_iobase);
}
static void <API key>(struct sps_event_notify *notify)
{
struct qce_device *pce_dev = (struct qce_device *)
((struct sps_event_notify *)notify)->user;
pce_dev->ce_sps.notify = *notify;
pr_debug("sps ev_id=%d, addr=0x%x, size=0x%x, flags=0x%x\n",
notify->event_id,
notify->data.transfer.iovec.addr,
notify->data.transfer.iovec.size,
notify->data.transfer.iovec.flags);
if (pce_dev->ce_sps.producer_state == QCE_PIPE_STATE_COMP) {
pce_dev->ce_sps.producer_state = QCE_PIPE_STATE_IDLE;
/* done */
_aead_complete(pce_dev);
} else {
int rc = 0;
pce_dev->ce_sps.producer_state = QCE_PIPE_STATE_COMP;
pce_dev->ce_sps.out_transfer.iovec_count = 0;
_qce_sps_add_data(GET_PHYS_ADDR(pce_dev->ce_sps.result_dump),
<API key>,
&pce_dev->ce_sps.out_transfer);
_qce_set_flag(&pce_dev->ce_sps.out_transfer,
SPS_IOVEC_FLAG_INT);
rc = sps_transfer(pce_dev->ce_sps.producer.pipe,
&pce_dev->ce_sps.out_transfer);
if (rc) {
pr_err("sps_xfr() fail (producer pipe=0x%x) rc = %d,",
(u32)pce_dev->ce_sps.producer.pipe, rc);
}
}
};
static void <API key>(struct sps_event_notify *notify)
{
struct qce_device *pce_dev = (struct qce_device *)
((struct sps_event_notify *)notify)->user;
pce_dev->ce_sps.notify = *notify;
pr_debug("sps ev_id=%d, addr=0x%x, size=0x%x, flags=0x%x\n",
notify->event_id,
notify->data.transfer.iovec.addr,
notify->data.transfer.iovec.size,
notify->data.transfer.iovec.flags);
/* done */
_sha_complete(pce_dev);
};
static void <API key>(struct sps_event_notify *notify)
{
struct qce_device *pce_dev = (struct qce_device *)
((struct sps_event_notify *)notify)->user;
pce_dev->ce_sps.notify = *notify;
pr_debug("sps ev_id=%d, addr=0x%x, size=0x%x, flags=0x%x\n",
notify->event_id,
notify->data.transfer.iovec.addr,
notify->data.transfer.iovec.size,
notify->data.transfer.iovec.flags);
if (pce_dev->ce_sps.producer_state == QCE_PIPE_STATE_COMP) {
pce_dev->ce_sps.producer_state = QCE_PIPE_STATE_IDLE;
/* done */
<API key>(pce_dev);
} else {
int rc = 0;
pce_dev->ce_sps.producer_state = QCE_PIPE_STATE_COMP;
pce_dev->ce_sps.out_transfer.iovec_count = 0;
_qce_sps_add_data(GET_PHYS_ADDR(pce_dev->ce_sps.result_dump),
<API key>,
&pce_dev->ce_sps.out_transfer);
_qce_set_flag(&pce_dev->ce_sps.out_transfer,
SPS_IOVEC_FLAG_INT);
rc = sps_transfer(pce_dev->ce_sps.producer.pipe,
&pce_dev->ce_sps.out_transfer);
if (rc) {
pr_err("sps_xfr() fail (producer pipe=0x%x) rc = %d,",
(u32)pce_dev->ce_sps.producer.pipe, rc);
}
}
};
static void qce_add_cmd_element(struct qce_device *pdev,
struct sps_command_element **cmd_ptr, u32 addr,
u32 data, struct sps_command_element **populate)
{
(*cmd_ptr)->addr = (uint32_t)(addr + pdev->phy_iobase);
(*cmd_ptr)->data = data;
(*cmd_ptr)->mask = 0xFFFFFFFF;
if (populate != NULL)
*populate = *cmd_ptr;
(*cmd_ptr)++ ;
}
static int <API key>(struct qce_device *pdev,
unsigned char **pvaddr, enum <API key> mode,
bool key_128)
{
struct sps_command_element *ce_vaddr;
uint32_t ce_vaddr_start;
struct qce_cmdlistptr_ops *cmdlistptr = &pdev->ce_sps.cmdlistptr;
struct qce_cmdlist_info *pcl_info = NULL;
int i = 0;
uint32_t encr_cfg = 0;
uint32_t key_reg = 0;
uint32_t xts_key_reg = 0;
uint32_t iv_reg = 0;
*pvaddr = (unsigned char *) ALIGN(((unsigned int)(*pvaddr)),
pdev->ce_sps.ce_burst_size);
ce_vaddr = (struct sps_command_element *)(*pvaddr);
ce_vaddr_start = (uint32_t)(*pvaddr);
/*
* Designate chunks of the allocated memory to various
* command list pointers related to AES cipher operations defined
* in ce_cmdlistptrs_ops structure.
*/
switch (mode) {
case QCE_MODE_CBC:
case QCE_MODE_CTR:
if (key_128 == true) {
cmdlistptr-><API key>.cmdlist =
(uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr-><API key>);
if (mode == QCE_MODE_CBC)
encr_cfg = pdev->reg.<API key>;
else
encr_cfg = pdev->reg.<API key>;
iv_reg = 4;
key_reg = 4;
xts_key_reg = 0;
} else {
cmdlistptr-><API key>.cmdlist =
(uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr-><API key>);
if (mode == QCE_MODE_CBC)
encr_cfg = pdev->reg.<API key>;
else
encr_cfg = pdev->reg.<API key>;
iv_reg = 4;
key_reg = 8;
xts_key_reg = 0;
}
break;
case QCE_MODE_ECB:
if (key_128 == true) {
cmdlistptr->cipher_aes_128_ecb.cmdlist =
(uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr->cipher_aes_128_ecb);
encr_cfg = pdev->reg.<API key>;
iv_reg = 0;
key_reg = 4;
xts_key_reg = 0;
} else {
cmdlistptr->cipher_aes_256_ecb.cmdlist =
(uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr->cipher_aes_256_ecb);
encr_cfg = pdev->reg.<API key>;
iv_reg = 0;
key_reg = 8;
xts_key_reg = 0;
}
break;
case QCE_MODE_XTS:
if (key_128 == true) {
cmdlistptr->cipher_aes_128_xts.cmdlist =
(uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr->cipher_aes_128_xts);
encr_cfg = pdev->reg.<API key>;
iv_reg = 4;
key_reg = 4;
xts_key_reg = 4;
} else {
cmdlistptr->cipher_aes_256_xts.cmdlist =
(uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr->cipher_aes_256_xts);
encr_cfg = pdev->reg.<API key>;
iv_reg = 4;
key_reg = 8;
xts_key_reg = 8;
}
break;
default:
pr_err("Unknown mode of operation %d received, exiting now\n",
mode);
return -EINVAL;
break;
}
/* clear status register */
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_STATUS_REG, 0, NULL);
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_CONFIG_REG,
pdev->reg.crypto_cfg_be, &pcl_info->crypto_cfg);
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_SEG_SIZE_REG, 0,
&pcl_info->seg_size);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, encr_cfg,
&pcl_info->encr_seg_cfg);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->encr_seg_size);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->encr_seg_start);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>,
(uint32_t)0xffffffff, &pcl_info->encr_mask);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->auth_seg_cfg);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->encr_key);
for (i = 1; i < key_reg; i++)
qce_add_cmd_element(pdev, &ce_vaddr,
(<API key> + i * sizeof(uint32_t)),
0, NULL);
if (xts_key_reg) {
qce_add_cmd_element(pdev, &ce_vaddr, <API key>,
0, &pcl_info->encr_xts_key);
for (i = 1; i < xts_key_reg; i++)
qce_add_cmd_element(pdev, &ce_vaddr,
(<API key> +
i * sizeof(uint32_t)), 0, NULL);
qce_add_cmd_element(pdev, &ce_vaddr,
<API key>, 0,
&pcl_info->encr_xts_du_size);
}
if (iv_reg) {
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->encr_cntr_iv);
for (i = 1; i < iv_reg; i++)
qce_add_cmd_element(pdev, &ce_vaddr,
(<API key> + i * sizeof(uint32_t)),
0, NULL);
}
/* Add dummy to align size to burst-size multiple */
if (mode == QCE_MODE_XTS) {
qce_add_cmd_element(pdev, &ce_vaddr, <API key>,
0, &pcl_info->auth_seg_size);
} else {
qce_add_cmd_element(pdev, &ce_vaddr, <API key>,
0, &pcl_info->auth_seg_size);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>,
0, &pcl_info->auth_seg_size);
}
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_CONFIG_REG,
pdev->reg.crypto_cfg_le, NULL);
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_GOPROC_REG,
((1 << CRYPTO_GO) | (1 << CRYPTO_RESULTS_DUMP)),
&pcl_info->go_proc);
pcl_info->size = (uint32_t)ce_vaddr - (uint32_t)ce_vaddr_start;
*pvaddr = (unsigned char *) ce_vaddr;
return 0;
}
static int <API key>(struct qce_device *pdev,
unsigned char **pvaddr, enum qce_cipher_alg_enum alg,
bool mode_cbc)
{
struct sps_command_element *ce_vaddr;
uint32_t ce_vaddr_start;
struct qce_cmdlistptr_ops *cmdlistptr = &pdev->ce_sps.cmdlistptr;
struct qce_cmdlist_info *pcl_info = NULL;
int i = 0;
uint32_t encr_cfg = 0;
uint32_t key_reg = 0;
uint32_t iv_reg = 0;
*pvaddr = (unsigned char *) ALIGN(((unsigned int)(*pvaddr)),
pdev->ce_sps.ce_burst_size);
ce_vaddr = (struct sps_command_element *)(*pvaddr);
ce_vaddr_start = (uint32_t)(*pvaddr);
/*
* Designate chunks of the allocated memory to various
* command list pointers related to cipher operations defined
* in ce_cmdlistptrs_ops structure.
*/
switch (alg) {
case CIPHER_ALG_DES:
if (mode_cbc) {
cmdlistptr->cipher_des_cbc.cmdlist =
(uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr->cipher_des_cbc);
encr_cfg = pdev->reg.encr_cfg_des_cbc;
iv_reg = 2;
key_reg = 2;
} else {
cmdlistptr->cipher_des_ecb.cmdlist =
(uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr->cipher_des_ecb);
encr_cfg = pdev->reg.encr_cfg_des_ecb;
iv_reg = 0;
key_reg = 2;
}
break;
case CIPHER_ALG_3DES:
if (mode_cbc) {
cmdlistptr->cipher_3des_cbc.cmdlist =
(uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr->cipher_3des_cbc);
encr_cfg = pdev->reg.encr_cfg_3des_cbc;
iv_reg = 2;
key_reg = 6;
} else {
cmdlistptr->cipher_3des_ecb.cmdlist =
(uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr->cipher_3des_ecb);
encr_cfg = pdev->reg.encr_cfg_3des_ecb;
iv_reg = 0;
key_reg = 6;
}
break;
default:
pr_err("Unknown algorithms %d received, exiting now\n", alg);
return -EINVAL;
break;
}
/* clear status register */
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_STATUS_REG, 0, NULL);
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_CONFIG_REG,
pdev->reg.crypto_cfg_be, &pcl_info->crypto_cfg);
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_SEG_SIZE_REG, 0,
&pcl_info->seg_size);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, encr_cfg,
&pcl_info->encr_seg_cfg);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->encr_seg_size);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->encr_seg_start);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->auth_seg_cfg);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->encr_key);
for (i = 1; i < key_reg; i++)
qce_add_cmd_element(pdev, &ce_vaddr,
(<API key> + i * sizeof(uint32_t)),
0, NULL);
if (iv_reg) {
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->encr_cntr_iv);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
NULL);
}
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_CONFIG_REG,
pdev->reg.crypto_cfg_le, NULL);
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_GOPROC_REG,
((1 << CRYPTO_GO) | (1 << CRYPTO_RESULTS_DUMP)),
&pcl_info->go_proc);
pcl_info->size = (uint32_t)ce_vaddr - (uint32_t)ce_vaddr_start;
*pvaddr = (unsigned char *) ce_vaddr;
return 0;
}
static int <API key>(struct qce_device *pdev,
unsigned char **pvaddr, enum qce_hash_alg_enum alg,
bool key_128)
{
struct sps_command_element *ce_vaddr;
uint32_t ce_vaddr_start;
struct qce_cmdlistptr_ops *cmdlistptr = &pdev->ce_sps.cmdlistptr;
struct qce_cmdlist_info *pcl_info = NULL;
int i = 0;
uint32_t key_reg = 0;
uint32_t auth_cfg = 0;
uint32_t iv_reg = 0;
*pvaddr = (unsigned char *) ALIGN(((unsigned int)(*pvaddr)),
pdev->ce_sps.ce_burst_size);
ce_vaddr_start = (uint32_t)(*pvaddr);
ce_vaddr = (struct sps_command_element *)(*pvaddr);
/*
* Designate chunks of the allocated memory to various
* command list pointers related to authentication operations
* defined in ce_cmdlistptrs_ops structure.
*/
switch (alg) {
case QCE_HASH_SHA1:
cmdlistptr->auth_sha1.cmdlist = (uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr->auth_sha1);
auth_cfg = pdev->reg.auth_cfg_sha1;
iv_reg = 5;
/* clear status register */
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_STATUS_REG,
0, NULL);
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_CONFIG_REG,
pdev->reg.crypto_cfg_be, &pcl_info->crypto_cfg);
break;
case QCE_HASH_SHA256:
cmdlistptr->auth_sha256.cmdlist = (uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr->auth_sha256);
auth_cfg = pdev->reg.auth_cfg_sha256;
iv_reg = 8;
/* clear status register */
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_STATUS_REG,
0, NULL);
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_CONFIG_REG,
pdev->reg.crypto_cfg_be, &pcl_info->crypto_cfg);
/* 1 dummy write */
qce_add_cmd_element(pdev, &ce_vaddr, <API key>,
0, NULL);
break;
case QCE_HASH_SHA1_HMAC:
cmdlistptr->auth_sha1_hmac.cmdlist = (uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr->auth_sha1_hmac);
auth_cfg = pdev->reg.auth_cfg_hmac_sha1;
key_reg = 16;
iv_reg = 5;
/* clear status register */
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_STATUS_REG,
0, NULL);
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_CONFIG_REG,
pdev->reg.crypto_cfg_be, &pcl_info->crypto_cfg);
break;
case <API key>:
cmdlistptr->auth_sha256_hmac.cmdlist = (uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr->auth_sha256_hmac);
auth_cfg = pdev->reg.<API key>;
key_reg = 16;
iv_reg = 8;
/* clear status register */
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_STATUS_REG, 0,
NULL);
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_CONFIG_REG,
pdev->reg.crypto_cfg_be, &pcl_info->crypto_cfg);
/* 1 dummy write */
qce_add_cmd_element(pdev, &ce_vaddr, <API key>,
0, NULL);
break;
case QCE_HASH_AES_CMAC:
if (key_128 == true) {
cmdlistptr->auth_aes_128_cmac.cmdlist =
(uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr->auth_aes_128_cmac);
auth_cfg = pdev->reg.auth_cfg_cmac_128;
key_reg = 4;
} else {
cmdlistptr->auth_aes_256_cmac.cmdlist =
(uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr->auth_aes_256_cmac);
auth_cfg = pdev->reg.auth_cfg_cmac_256;
key_reg = 8;
}
/* clear status register */
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_STATUS_REG, 0,
NULL);
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_CONFIG_REG,
pdev->reg.crypto_cfg_be, &pcl_info->crypto_cfg);
/* 1 dummy write */
qce_add_cmd_element(pdev, &ce_vaddr, <API key>,
0, NULL);
break;
default:
pr_err("Unknown algorithms %d received, exiting now\n", alg);
return -EINVAL;
break;
}
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_SEG_SIZE_REG, 0,
&pcl_info->seg_size);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->encr_seg_cfg);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>,
auth_cfg, &pcl_info->auth_seg_cfg);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->auth_seg_size);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->auth_seg_start);
if (alg == QCE_HASH_AES_CMAC) {
/* reset auth iv, bytecount and key registers */
for (i = 0; i < 16; i++)
qce_add_cmd_element(pdev, &ce_vaddr,
(CRYPTO_AUTH_IV0_REG + i * sizeof(uint32_t)),
0, NULL);
for (i = 0; i < 16; i++)
qce_add_cmd_element(pdev, &ce_vaddr,
(<API key> + i*sizeof(uint32_t)),
0, NULL);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>,
0, NULL);
} else {
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_AUTH_IV0_REG, 0,
&pcl_info->auth_iv);
for (i = 1; i < iv_reg; i++)
qce_add_cmd_element(pdev, &ce_vaddr,
(CRYPTO_AUTH_IV0_REG + i*sizeof(uint32_t)),
0, NULL);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>,
0, &pcl_info->auth_bytecount);
}
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0, NULL);
if (key_reg) {
qce_add_cmd_element(pdev, &ce_vaddr,
<API key>, 0, &pcl_info->auth_key);
for (i = 1; i < key_reg; i++)
qce_add_cmd_element(pdev, &ce_vaddr,
(<API key> + i*sizeof(uint32_t)),
0, NULL);
}
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_CONFIG_REG,
pdev->reg.crypto_cfg_le, NULL);
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_GOPROC_REG,
((1 << CRYPTO_GO) | (1 << CRYPTO_RESULTS_DUMP)),
&pcl_info->go_proc);
pcl_info->size = (uint32_t)ce_vaddr - (uint32_t)ce_vaddr_start;
*pvaddr = (unsigned char *) ce_vaddr;
return 0;
}
static int <API key>(struct qce_device *pdev,
unsigned char **pvaddr,
uint32_t alg,
uint32_t mode,
uint32_t key_size)
{
struct sps_command_element *ce_vaddr;
uint32_t ce_vaddr_start;
struct qce_cmdlistptr_ops *cmdlistptr = &pdev->ce_sps.cmdlistptr;
struct qce_cmdlist_info *pcl_info = NULL;
uint32_t key_reg;
uint32_t iv_reg;
uint32_t i;
uint32_t enciv_in_word;
uint32_t encr_cfg;
*pvaddr = (unsigned char *) ALIGN(((unsigned int)(*pvaddr)),
pdev->ce_sps.ce_burst_size);
ce_vaddr_start = (uint32_t)(*pvaddr);
ce_vaddr = (struct sps_command_element *)(*pvaddr);
switch (alg) {
case CIPHER_ALG_DES:
switch (mode) {
case QCE_MODE_ECB:
cmdlistptr-><API key>.cmdlist =
(uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr-><API key>);
encr_cfg = pdev->reg.encr_cfg_des_ecb;
break;
case QCE_MODE_CBC:
cmdlistptr-><API key>.cmdlist =
(uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr-><API key>);
encr_cfg = pdev->reg.encr_cfg_des_cbc;
break;
default:
return -EINVAL;
};
enciv_in_word = 2;
break;
case CIPHER_ALG_3DES:
switch (mode) {
case QCE_MODE_ECB:
cmdlistptr-><API key>.cmdlist =
(uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr-><API key>);
encr_cfg = pdev->reg.encr_cfg_3des_ecb;
break;
case QCE_MODE_CBC:
cmdlistptr-><API key>.cmdlist =
(uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr-><API key>);
encr_cfg = pdev->reg.encr_cfg_3des_cbc;
break;
default:
return -EINVAL;
};
enciv_in_word = 2;
break;
case CIPHER_ALG_AES:
switch (mode) {
case QCE_MODE_ECB:
if (key_size == AES128_KEY_SIZE) {
cmdlistptr-><API key>.cmdlist =
(uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr->
<API key>);
encr_cfg = pdev->reg.<API key>;
} else if (key_size == AES256_KEY_SIZE) {
cmdlistptr-><API key>.cmdlist =
(uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr->
<API key>);
encr_cfg = pdev->reg.<API key>;
} else {
return -EINVAL;
}
break;
case QCE_MODE_CBC:
if (key_size == AES128_KEY_SIZE) {
cmdlistptr-><API key>.cmdlist =
(uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr->
<API key>);
encr_cfg = pdev->reg.<API key>;
} else if (key_size == AES256_KEY_SIZE) {
cmdlistptr-><API key>.cmdlist =
(uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr->
<API key>);
encr_cfg = pdev->reg.<API key>;
} else {
return -EINVAL;
}
break;
default:
return -EINVAL;
};
enciv_in_word = 4;
break;
default:
return -EINVAL;
};
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_STATUS_REG, 0, NULL);
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_CONFIG_REG,
pdev->reg.crypto_cfg_be, &pcl_info->crypto_cfg);
key_reg = key_size/sizeof(uint32_t);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->encr_key);
for (i = 1; i < key_reg; i++)
qce_add_cmd_element(pdev, &ce_vaddr,
(<API key> + i * sizeof(uint32_t)),
0, NULL);
if (mode != QCE_MODE_ECB) {
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->encr_cntr_iv);
for (i = 1; i < enciv_in_word; i++)
qce_add_cmd_element(pdev, &ce_vaddr,
(<API key> + i * sizeof(uint32_t)),
0, NULL);
};
iv_reg = 5;
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_AUTH_IV0_REG, 0,
&pcl_info->auth_iv);
for (i = 1; i < iv_reg; i++)
qce_add_cmd_element(pdev, &ce_vaddr,
(CRYPTO_AUTH_IV0_REG + i*sizeof(uint32_t)),
0, NULL);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>,
0, &pcl_info->auth_bytecount);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0, NULL);
key_reg = SHA_HMAC_KEY_SIZE/sizeof(uint32_t);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->auth_key);
for (i = 1; i < key_reg; i++)
qce_add_cmd_element(pdev, &ce_vaddr,
(<API key> + i*sizeof(uint32_t)), 0, NULL);
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_SEG_SIZE_REG, 0,
&pcl_info->seg_size);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, encr_cfg,
&pcl_info->encr_seg_cfg);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->encr_seg_size);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->encr_seg_start);
qce_add_cmd_element(
pdev,
&ce_vaddr,
<API key>,
pdev->reg.<API key>,
&pcl_info->auth_seg_cfg);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->auth_seg_size);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->auth_seg_start);
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_CONFIG_REG,
pdev->reg.crypto_cfg_le, NULL);
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_GOPROC_REG,
((1 << CRYPTO_GO) | (1 << CRYPTO_RESULTS_DUMP)),
&pcl_info->go_proc);
pcl_info->size = (uint32_t)ce_vaddr - (uint32_t)ce_vaddr_start;
*pvaddr = (unsigned char *) ce_vaddr;
return 0;
}
static int <API key>(struct qce_device *pdev,
unsigned char **pvaddr, bool key_128)
{
struct sps_command_element *ce_vaddr;
uint32_t ce_vaddr_start;
struct qce_cmdlistptr_ops *cmdlistptr = &pdev->ce_sps.cmdlistptr;
struct qce_cmdlist_info *pcl_info = NULL;
int i = 0;
uint32_t encr_cfg = 0;
uint32_t auth_cfg = 0;
uint32_t key_reg = 0;
*pvaddr = (unsigned char *) ALIGN(((unsigned int)(*pvaddr)),
pdev->ce_sps.ce_burst_size);
ce_vaddr_start = (uint32_t)(*pvaddr);
ce_vaddr = (struct sps_command_element *)(*pvaddr);
/*
* Designate chunks of the allocated memory to various
* command list pointers related to aead operations
* defined in ce_cmdlistptrs_ops structure.
*/
if (key_128 == true) {
cmdlistptr->aead_aes_128_ccm.cmdlist = (uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr->aead_aes_128_ccm);
auth_cfg = pdev->reg.<API key>;
encr_cfg = pdev->reg.<API key>;
key_reg = 4;
} else {
cmdlistptr->aead_aes_256_ccm.cmdlist = (uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr->aead_aes_256_ccm);
auth_cfg = pdev->reg.<API key>;
encr_cfg = pdev->reg.<API key>;
key_reg = 8;
}
/* clear status register */
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_STATUS_REG, 0, NULL);
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_CONFIG_REG,
pdev->reg.crypto_cfg_be, &pcl_info->crypto_cfg);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0, NULL);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
NULL);
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_SEG_SIZE_REG, 0,
&pcl_info->seg_size);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>,
encr_cfg, &pcl_info->encr_seg_cfg);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->encr_seg_size);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->encr_seg_start);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>,
(uint32_t)0xffffffff, &pcl_info->encr_mask);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>,
auth_cfg, &pcl_info->auth_seg_cfg);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->auth_seg_size);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->auth_seg_start);
/* reset auth iv, bytecount and key registers */
for (i = 0; i < 8; i++)
qce_add_cmd_element(pdev, &ce_vaddr,
(CRYPTO_AUTH_IV0_REG + i * sizeof(uint32_t)),
0, NULL);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>,
0, NULL);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>,
0, NULL);
for (i = 0; i < 16; i++)
qce_add_cmd_element(pdev, &ce_vaddr,
(<API key> + i * sizeof(uint32_t)),
0, NULL);
/* set auth key */
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->auth_key);
for (i = 1; i < key_reg; i++)
qce_add_cmd_element(pdev, &ce_vaddr,
(<API key> + i * sizeof(uint32_t)),
0, NULL);
/* set NONCE info */
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_<API key>, 0,
&pcl_info->auth_nonce_info);
for (i = 1; i < 4; i++)
qce_add_cmd_element(pdev, &ce_vaddr,
(CRYPTO_<API key> +
i * sizeof(uint32_t)), 0, NULL);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->encr_key);
for (i = 1; i < key_reg; i++)
qce_add_cmd_element(pdev, &ce_vaddr,
(<API key> + i * sizeof(uint32_t)),
0, NULL);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->encr_cntr_iv);
for (i = 1; i < 4; i++)
qce_add_cmd_element(pdev, &ce_vaddr,
(<API key> + i * sizeof(uint32_t)),
0, NULL);
qce_add_cmd_element(pdev, &ce_vaddr, <API key>, 0,
&pcl_info->encr_ccm_cntr_iv);
for (i = 1; i < 4; i++)
qce_add_cmd_element(pdev, &ce_vaddr,
(<API key> + i * sizeof(uint32_t)),
0, NULL);
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_CONFIG_REG,
pdev->reg.crypto_cfg_le, NULL);
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_GOPROC_REG,
((1 << CRYPTO_GO) | (1 << CRYPTO_RESULTS_DUMP)),
&pcl_info->go_proc);
pcl_info->size = (uint32_t)ce_vaddr - (uint32_t)ce_vaddr_start;
*pvaddr = (unsigned char *) ce_vaddr;
return 0;
}
static int <API key>(struct qce_device *pdev,
unsigned char **pvaddr)
{
struct sps_command_element *ce_vaddr;
uint32_t ce_vaddr_start = (uint32_t)(*pvaddr);
struct qce_cmdlistptr_ops *cmdlistptr = &pdev->ce_sps.cmdlistptr;
struct qce_cmdlist_info *pcl_info = NULL;
*pvaddr = (unsigned char *) ALIGN(((unsigned int)(*pvaddr)),
pdev->ce_sps.ce_burst_size);
ce_vaddr = (struct sps_command_element *)(*pvaddr);
cmdlistptr->unlock_all_pipes.cmdlist = (uint32_t)ce_vaddr;
pcl_info = &(cmdlistptr->unlock_all_pipes);
/*
* Designate chunks of the allocated memory to command list
* to unlock pipes.
*/
qce_add_cmd_element(pdev, &ce_vaddr, CRYPTO_CONFIG_REG,
CRYPTO_CONFIG_RESET, NULL);
pcl_info->size = (uint32_t)ce_vaddr - (uint32_t)ce_vaddr_start;
*pvaddr = (unsigned char *) ce_vaddr;
return 0;
}
static int <API key>(struct qce_device *pdev,
unsigned char **pvaddr)
{
struct sps_command_element *ce_vaddr =
(struct sps_command_element *)(*pvaddr);
/*
* Designate chunks of the allocated memory to various
* command list pointers related to operations defined
* in ce_cmdlistptrs_ops structure.
*/
ce_vaddr =
(struct sps_command_element *) ALIGN(((unsigned int) ce_vaddr),
pdev->ce_sps.ce_burst_size);
*pvaddr = (unsigned char *) ce_vaddr;
<API key>(pdev, pvaddr, QCE_MODE_CBC, true);
<API key>(pdev, pvaddr, QCE_MODE_CTR, true);
<API key>(pdev, pvaddr, QCE_MODE_ECB, true);
<API key>(pdev, pvaddr, QCE_MODE_XTS, true);
<API key>(pdev, pvaddr, QCE_MODE_CBC, false);
<API key>(pdev, pvaddr, QCE_MODE_CTR, false);
<API key>(pdev, pvaddr, QCE_MODE_ECB, false);
<API key>(pdev, pvaddr, QCE_MODE_XTS, false);
<API key>(pdev, pvaddr, CIPHER_ALG_DES, true);
<API key>(pdev, pvaddr, CIPHER_ALG_DES, false);
<API key>(pdev, pvaddr, CIPHER_ALG_3DES, true);
<API key>(pdev, pvaddr, CIPHER_ALG_3DES, false);
<API key>(pdev, pvaddr, QCE_HASH_SHA1, false);
<API key>(pdev, pvaddr, QCE_HASH_SHA256, false);
<API key>(pdev, pvaddr, QCE_HASH_SHA1_HMAC, false);
<API key>(pdev, pvaddr, <API key>, false);
<API key>(pdev, pvaddr, QCE_HASH_AES_CMAC, true);
<API key>(pdev, pvaddr, QCE_HASH_AES_CMAC, false);
<API key>(pdev, pvaddr, CIPHER_ALG_DES, QCE_MODE_CBC,
DES_KEY_SIZE);
<API key>(pdev, pvaddr, CIPHER_ALG_DES, QCE_MODE_ECB,
DES_KEY_SIZE);
<API key>(pdev, pvaddr, CIPHER_ALG_3DES, QCE_MODE_CBC,
DES3_EDE_KEY_SIZE);
<API key>(pdev, pvaddr, CIPHER_ALG_3DES, QCE_MODE_ECB,
DES3_EDE_KEY_SIZE);
<API key>(pdev, pvaddr, CIPHER_ALG_AES, QCE_MODE_CBC,
AES128_KEY_SIZE);
<API key>(pdev, pvaddr, CIPHER_ALG_AES, QCE_MODE_ECB,
AES128_KEY_SIZE);
<API key>(pdev, pvaddr, CIPHER_ALG_AES, QCE_MODE_CBC,
AES256_KEY_SIZE);
<API key>(pdev, pvaddr, CIPHER_ALG_AES, QCE_MODE_ECB,
AES256_KEY_SIZE);
<API key>(pdev, pvaddr, true);
<API key>(pdev, pvaddr, false);
<API key>(pdev, pvaddr);
return 0;
}
static int <API key>(struct qce_device *pce_dev)
{
unsigned char *vaddr;
vaddr = pce_dev->coh_vmem;
vaddr = (unsigned char *) ALIGN(((unsigned int)vaddr),
pce_dev->ce_sps.ce_burst_size);
/* Allow for 256 descriptor (cmd and data) entries per pipe */
pce_dev->ce_sps.in_transfer.iovec = (struct sps_iovec *)vaddr;
pce_dev->ce_sps.in_transfer.iovec_phys =
(uint32_t)GET_PHYS_ADDR(vaddr);
vaddr += QCE_MAX_NUM_DSCR * sizeof(struct sps_iovec);
pce_dev->ce_sps.out_transfer.iovec = (struct sps_iovec *)vaddr;
pce_dev->ce_sps.out_transfer.iovec_phys =
(uint32_t)GET_PHYS_ADDR(vaddr);
vaddr += QCE_MAX_NUM_DSCR * sizeof(struct sps_iovec);
if (pce_dev->support_cmd_dscr)
<API key>(pce_dev, &vaddr);
vaddr = (unsigned char *) ALIGN(((unsigned int)vaddr),
pce_dev->ce_sps.ce_burst_size);
pce_dev->ce_sps.result_dump = (uint32_t)vaddr;
pce_dev->ce_sps.result = (struct <API key> *)vaddr;
vaddr += <API key>;
pce_dev->ce_sps.ignore_buffer = (uint32_t)vaddr;
vaddr += pce_dev->ce_sps.ce_burst_size * 2;
if ((vaddr - pce_dev->coh_vmem) > pce_dev->memsize)
panic("qce50: Not enough coherent memory. Allocate %x , need %x",
pce_dev->memsize, vaddr - pce_dev->coh_vmem);
return 0;
}
static int qce_init_ce_cfg_val(struct qce_device *pce_dev)
{
uint32_t beats = (pce_dev->ce_sps.ce_burst_size >> 3) - 1;
uint32_t pipe_pair = pce_dev->ce_sps.pipe_pair_index;
pce_dev->reg.crypto_cfg_be = (beats << CRYPTO_REQ_SIZE) |
BIT(<API key>) | BIT(<API key>) |
BIT(<API key>) | (0 << <API key>) |
(pipe_pair << <API key>);
pce_dev->reg.crypto_cfg_le =
(pce_dev->reg.crypto_cfg_be | <API key>);
/* Initialize encr_cfg register for AES alg */
pce_dev->reg.<API key> =
(<API key> << CRYPTO_ENCR_KEY_SZ) |
(CRYPTO_ENCR_ALG_AES << CRYPTO_ENCR_ALG) |
(<API key> << CRYPTO_ENCR_MODE);
pce_dev->reg.<API key> =
(<API key> << CRYPTO_ENCR_KEY_SZ) |
(CRYPTO_ENCR_ALG_AES << CRYPTO_ENCR_ALG) |
(<API key> << CRYPTO_ENCR_MODE);
pce_dev->reg.<API key> =
(<API key> << CRYPTO_ENCR_KEY_SZ) |
(CRYPTO_ENCR_ALG_AES << CRYPTO_ENCR_ALG) |
(<API key> << CRYPTO_ENCR_MODE);
pce_dev->reg.<API key> =
(<API key> << CRYPTO_ENCR_KEY_SZ) |
(CRYPTO_ENCR_ALG_AES << CRYPTO_ENCR_ALG) |
(<API key> << CRYPTO_ENCR_MODE);
pce_dev->reg.<API key> =
(<API key> << CRYPTO_ENCR_KEY_SZ) |
(CRYPTO_ENCR_ALG_AES << CRYPTO_ENCR_ALG) |
(<API key> << CRYPTO_ENCR_MODE);
pce_dev->reg.<API key> =
(<API key> << CRYPTO_ENCR_KEY_SZ) |
(CRYPTO_ENCR_ALG_AES << CRYPTO_ENCR_ALG) |
(<API key> << CRYPTO_ENCR_MODE);
pce_dev->reg.<API key> =
(<API key> << CRYPTO_ENCR_KEY_SZ) |
(CRYPTO_ENCR_ALG_AES << CRYPTO_ENCR_ALG) |
(<API key> << CRYPTO_ENCR_MODE);
pce_dev->reg.<API key> =
(<API key> << CRYPTO_ENCR_KEY_SZ) |
(CRYPTO_ENCR_ALG_AES << CRYPTO_ENCR_ALG) |
(<API key> << CRYPTO_ENCR_MODE);
pce_dev->reg.<API key> =
(<API key> << CRYPTO_ENCR_KEY_SZ) |
(CRYPTO_ENCR_ALG_AES << CRYPTO_ENCR_ALG) |
(<API key> << CRYPTO_ENCR_MODE)|
(CRYPTO_LAST_CCM_XFR << CRYPTO_LAST_CCM);
pce_dev->reg.<API key> =
(<API key> << CRYPTO_ENCR_KEY_SZ) |
(CRYPTO_ENCR_ALG_AES << CRYPTO_ENCR_ALG) |
(<API key> << CRYPTO_ENCR_MODE) |
(CRYPTO_LAST_CCM_XFR << CRYPTO_LAST_CCM);
/* Initialize encr_cfg register for DES alg */
pce_dev->reg.encr_cfg_des_ecb =
(<API key> << CRYPTO_ENCR_KEY_SZ) |
(CRYPTO_ENCR_ALG_DES << CRYPTO_ENCR_ALG) |
(<API key> << CRYPTO_ENCR_MODE);
pce_dev->reg.encr_cfg_des_cbc =
(<API key> << CRYPTO_ENCR_KEY_SZ) |
(CRYPTO_ENCR_ALG_DES << CRYPTO_ENCR_ALG) |
(<API key> << CRYPTO_ENCR_MODE);
pce_dev->reg.encr_cfg_3des_ecb =
(<API key> << CRYPTO_ENCR_KEY_SZ) |
(CRYPTO_ENCR_ALG_DES << CRYPTO_ENCR_ALG) |
(<API key> << CRYPTO_ENCR_MODE);
pce_dev->reg.encr_cfg_3des_cbc =
(<API key> << CRYPTO_ENCR_KEY_SZ) |
(CRYPTO_ENCR_ALG_DES << CRYPTO_ENCR_ALG) |
(<API key> << CRYPTO_ENCR_MODE);
/* Initialize auth_cfg register for CMAC alg */
pce_dev->reg.auth_cfg_cmac_128 =
(1 << CRYPTO_LAST) | (1 << CRYPTO_FIRST) |
(<API key> << CRYPTO_AUTH_MODE)|
(CRYPTO_<API key> << CRYPTO_AUTH_SIZE) |
(CRYPTO_AUTH_ALG_AES << CRYPTO_AUTH_ALG) |
(<API key> << <API key>);
pce_dev->reg.auth_cfg_cmac_256 =
(1 << CRYPTO_LAST) | (1 << CRYPTO_FIRST) |
(<API key> << CRYPTO_AUTH_MODE)|
(CRYPTO_<API key> << CRYPTO_AUTH_SIZE) |
(CRYPTO_AUTH_ALG_AES << CRYPTO_AUTH_ALG) |
(<API key> << <API key>);
/* Initialize auth_cfg register for HMAC alg */
pce_dev->reg.auth_cfg_hmac_sha1 =
(<API key> << CRYPTO_AUTH_MODE)|
(<API key> << CRYPTO_AUTH_SIZE) |
(CRYPTO_AUTH_ALG_SHA << CRYPTO_AUTH_ALG) |
(<API key> << CRYPTO_AUTH_POS);
pce_dev->reg.<API key> =
(<API key> << CRYPTO_AUTH_MODE)|
(<API key> << CRYPTO_AUTH_SIZE) |
(CRYPTO_AUTH_ALG_SHA << CRYPTO_AUTH_ALG) |
(<API key> << CRYPTO_AUTH_POS);
/* Initialize auth_cfg register for SHA1/256 alg */
pce_dev->reg.auth_cfg_sha1 =
(<API key> << CRYPTO_AUTH_MODE)|
(<API key> << CRYPTO_AUTH_SIZE) |
(CRYPTO_AUTH_ALG_SHA << CRYPTO_AUTH_ALG) |
(<API key> << CRYPTO_AUTH_POS);
pce_dev->reg.auth_cfg_sha256 =
(<API key> << CRYPTO_AUTH_MODE)|
(<API key> << CRYPTO_AUTH_SIZE) |
(CRYPTO_AUTH_ALG_SHA << CRYPTO_AUTH_ALG) |
(<API key> << CRYPTO_AUTH_POS);
/* Initialize auth_cfg register for AEAD alg */
pce_dev->reg.<API key> =
(<API key> << CRYPTO_AUTH_MODE)|
(<API key> << CRYPTO_AUTH_SIZE) |
(CRYPTO_AUTH_ALG_SHA << CRYPTO_AUTH_ALG) |
(1 << CRYPTO_LAST) | (1 << CRYPTO_FIRST);
pce_dev->reg.<API key> =
(<API key> << CRYPTO_AUTH_MODE)|
(<API key> << CRYPTO_AUTH_SIZE) |
(CRYPTO_AUTH_ALG_SHA << CRYPTO_AUTH_ALG) |
(1 << CRYPTO_LAST) | (1 << CRYPTO_FIRST);
pce_dev->reg.<API key> =
(1 << CRYPTO_LAST) | (1 << CRYPTO_FIRST) |
(<API key> << CRYPTO_AUTH_MODE)|
(CRYPTO_AUTH_ALG_AES << CRYPTO_AUTH_ALG) |
(<API key> << <API key>) |
((MAX_NONCE/sizeof(uint32_t)) << CRYPTO_<API key>);
pce_dev->reg.<API key> &= ~(1 << <API key>);
pce_dev->reg.<API key> =
(1 << CRYPTO_LAST) | (1 << CRYPTO_FIRST) |
(<API key> << CRYPTO_AUTH_MODE)|
(CRYPTO_AUTH_ALG_AES << CRYPTO_AUTH_ALG) |
(<API key> << <API key>) |
((MAX_NONCE/sizeof(uint32_t)) << CRYPTO_<API key>);
pce_dev->reg.<API key> &= ~(1 << <API key>);
return 0;
}
static int _qce_aead_ccm_req(void *handle, struct qce_req *q_req)
{
struct qce_device *pce_dev = (struct qce_device *) handle;
struct aead_request *areq = (struct aead_request *) q_req->areq;
uint32_t authsize = q_req->authsize;
uint32_t totallen_in, out_len;
uint32_t hw_pad_out = 0;
int rc = 0;
int ce_burst_size;
struct qce_cmdlist_info *cmdlistinfo = NULL;
ce_burst_size = pce_dev->ce_sps.ce_burst_size;
totallen_in = areq->cryptlen + areq->assoclen;
if (q_req->dir == QCE_ENCRYPT) {
q_req->cryptlen = areq->cryptlen;
out_len = areq->cryptlen + authsize;
hw_pad_out = ALIGN(authsize, ce_burst_size) - authsize;
} else {
q_req->cryptlen = areq->cryptlen - authsize;
out_len = q_req->cryptlen;
hw_pad_out = authsize;
}
if (pce_dev->ce_sps.minor_version == 0) {
/*
* For crypto 5.0 that has burst size alignment requirement
* for data descritpor,
* the agent above(qcrypto) prepares the src scatter list with
* memory starting with associated data, followed by
* data stream to be ciphered.
* The destination scatter list is pointing to the same
* data area as source.
*/
pce_dev->src_nents = count_sg(areq->src, totallen_in);
} else {
pce_dev->src_nents = count_sg(areq->src, areq->cryptlen);
}
pce_dev->assoc_nents = count_sg(areq->assoc, areq->assoclen);
pce_dev->authsize = q_req->authsize;
/* associated data input */
qce_dma_map_sg(pce_dev->pdev, areq->assoc, pce_dev->assoc_nents,
DMA_TO_DEVICE);
/* cipher input */
qce_dma_map_sg(pce_dev->pdev, areq->src, pce_dev->src_nents,
(areq->src == areq->dst) ? DMA_BIDIRECTIONAL :
DMA_TO_DEVICE);
/* cipher + mac output for encryption */
if (areq->src != areq->dst) {
if (pce_dev->ce_sps.minor_version == 0)
/*
* The destination scatter list is pointing to the same
* data area as src.
* Note, the associated data will be pass-through
* at the begining of destination area.
*/
pce_dev->dst_nents = count_sg(areq->dst,
out_len + areq->assoclen);
else
pce_dev->dst_nents = count_sg(areq->dst, out_len);
qce_dma_map_sg(pce_dev->pdev, areq->dst, pce_dev->dst_nents,
DMA_FROM_DEVICE);
} else {
pce_dev->dst_nents = pce_dev->src_nents;
}
if (pce_dev->support_cmd_dscr) {
<API key>(pce_dev, q_req, &cmdlistinfo);
/* set up crypto device */
rc = _ce_setup_cipher(pce_dev, q_req, totallen_in,
areq->assoclen, cmdlistinfo);
} else {
/* set up crypto device */
rc = <API key>(pce_dev, q_req, totallen_in,
areq->assoclen);
}
if (rc < 0)
goto bad;
/* setup for callback, and issue command to bam */
pce_dev->areq = q_req->areq;
pce_dev->qce_cb = q_req->qce_cb;
/* Register callback event for EOT (End of transfer) event. */
pce_dev->ce_sps.producer.event.callback = <API key>;
pce_dev->ce_sps.producer.event.options = SPS_O_DESC_DONE;
rc = sps_register_event(pce_dev->ce_sps.producer.pipe,
&pce_dev->ce_sps.producer.event);
if (rc) {
pr_err("Producer callback registration failed rc = %d\n", rc);
goto bad;
}
<API key>(pce_dev);
if (pce_dev->support_cmd_dscr)
_qce_sps_add_cmd(pce_dev, SPS_IOVEC_FLAG_LOCK, cmdlistinfo,
&pce_dev->ce_sps.in_transfer);
if (pce_dev->ce_sps.minor_version == 0) {
if (<API key>(pce_dev, areq->src, totallen_in,
&pce_dev->ce_sps.in_transfer))
goto bad;
_qce_set_flag(&pce_dev->ce_sps.in_transfer,
SPS_IOVEC_FLAG_EOT|SPS_IOVEC_FLAG_NWD);
/*
* The destination data should be big enough to
* include CCM padding.
*/
if (<API key>(pce_dev, areq->dst, out_len +
areq->assoclen + hw_pad_out,
&pce_dev->ce_sps.out_transfer))
goto bad;
if (totallen_in > SPS_MAX_PKT_SIZE) {
_qce_set_flag(&pce_dev->ce_sps.out_transfer,
SPS_IOVEC_FLAG_INT);
pce_dev->ce_sps.producer.event.options =
SPS_O_DESC_DONE;
pce_dev->ce_sps.producer_state = QCE_PIPE_STATE_IDLE;
} else {
if (_qce_sps_add_data(GET_PHYS_ADDR(
pce_dev->ce_sps.result_dump),
<API key>,
&pce_dev->ce_sps.out_transfer))
goto bad;
_qce_set_flag(&pce_dev->ce_sps.out_transfer,
SPS_IOVEC_FLAG_INT);
pce_dev->ce_sps.producer_state = QCE_PIPE_STATE_COMP;
}
} else {
if (<API key>(pce_dev, areq->assoc, areq->assoclen,
&pce_dev->ce_sps.in_transfer))
goto bad;
if (<API key>(pce_dev, areq->src, areq->cryptlen,
&pce_dev->ce_sps.in_transfer))
goto bad;
_qce_set_flag(&pce_dev->ce_sps.in_transfer,
SPS_IOVEC_FLAG_EOT|SPS_IOVEC_FLAG_NWD);
/* Pass through to ignore associated data*/
if (_qce_sps_add_data(
GET_PHYS_ADDR(pce_dev->ce_sps.ignore_buffer),
areq->assoclen,
&pce_dev->ce_sps.out_transfer))
goto bad;
if (<API key>(pce_dev, areq->dst, out_len,
&pce_dev->ce_sps.out_transfer))
goto bad;
/* Pass through to ignore hw_pad (padding of the MAC data) */
if (_qce_sps_add_data(
GET_PHYS_ADDR(pce_dev->ce_sps.ignore_buffer),
hw_pad_out, &pce_dev->ce_sps.out_transfer))
goto bad;
if (totallen_in > SPS_MAX_PKT_SIZE) {
_qce_set_flag(&pce_dev->ce_sps.out_transfer,
SPS_IOVEC_FLAG_INT);
pce_dev->ce_sps.producer_state = QCE_PIPE_STATE_IDLE;
} else {
if (_qce_sps_add_data(
GET_PHYS_ADDR(pce_dev->ce_sps.result_dump),
<API key>,
&pce_dev->ce_sps.out_transfer))
goto bad;
_qce_set_flag(&pce_dev->ce_sps.out_transfer,
SPS_IOVEC_FLAG_INT);
pce_dev->ce_sps.producer_state = QCE_PIPE_STATE_COMP;
}
}
rc = _qce_sps_transfer(pce_dev);
if (rc)
goto bad;
return 0;
bad:
if (pce_dev->assoc_nents) {
qce_dma_unmap_sg(pce_dev->pdev, areq->assoc,
pce_dev->assoc_nents, DMA_TO_DEVICE);
}
if (pce_dev->src_nents) {
qce_dma_unmap_sg(pce_dev->pdev, areq->src, pce_dev->src_nents,
(areq->src == areq->dst) ? DMA_BIDIRECTIONAL :
DMA_TO_DEVICE);
}
if (areq->src != areq->dst) {
qce_dma_unmap_sg(pce_dev->pdev, areq->dst, pce_dev->dst_nents,
DMA_FROM_DEVICE);
}
return rc;
}
int qce_aead_req(void *handle, struct qce_req *q_req)
{
struct qce_device *pce_dev;
struct aead_request *areq;
uint32_t authsize;
struct crypto_aead *aead;
uint32_t ivsize;
uint32_t totallen;
int rc;
struct qce_cmdlist_info *cmdlistinfo = NULL;
if (q_req->mode == QCE_MODE_CCM)
return _qce_aead_ccm_req(handle, q_req);
pce_dev = (struct qce_device *) handle;
areq = (struct aead_request *) q_req->areq;
aead = crypto_aead_reqtfm(areq);
ivsize = crypto_aead_ivsize(aead);
q_req->ivsize = ivsize;
authsize = q_req->authsize;
if (q_req->dir == QCE_ENCRYPT)
q_req->cryptlen = areq->cryptlen;
else
q_req->cryptlen = areq->cryptlen - authsize;
totallen = q_req->cryptlen + areq->assoclen + ivsize;
if (pce_dev->support_cmd_dscr) {
cmdlistinfo = <API key>(pce_dev, q_req);
if (cmdlistinfo == NULL) {
pr_err("Unsupported aead ciphering algorithm %d, mode %d, ciphering key length %d, auth digest size %d\n",
q_req->alg, q_req->mode, q_req->encklen,
q_req->authsize);
return -EINVAL;
}
/* set up crypto device */
rc = _ce_setup_aead(pce_dev, q_req, totallen,
areq->assoclen + ivsize, cmdlistinfo);
if (rc < 0)
return -EINVAL;
};
pce_dev->assoc_nents = count_sg(areq->assoc, areq->assoclen);
if (pce_dev->ce_sps.minor_version == 0) {
/*
* For crypto 5.0 that has burst size alignment requirement
* for data descritpor,
* the agent above(qcrypto) prepares the src scatter list with
* memory starting with associated data, followed by
* iv, and data stream to be ciphered.
*/
pce_dev->src_nents = count_sg(areq->src, totallen);
} else {
pce_dev->src_nents = count_sg(areq->src, q_req->cryptlen);
};
pce_dev->ivsize = q_req->ivsize;
pce_dev->authsize = q_req->authsize;
pce_dev->phy_iv_in = 0;
/* associated data input */
qce_dma_map_sg(pce_dev->pdev, areq->assoc, pce_dev->assoc_nents,
DMA_TO_DEVICE);
/* cipher input */
qce_dma_map_sg(pce_dev->pdev, areq->src, pce_dev->src_nents,
(areq->src == areq->dst) ? DMA_BIDIRECTIONAL :
DMA_TO_DEVICE);
/* cipher + mac output for encryption */
if (areq->src != areq->dst) {
if (pce_dev->ce_sps.minor_version == 0)
/*
* The destination scatter list is pointing to the same
* data area as source.
*/
pce_dev->dst_nents = count_sg(areq->dst, totallen);
else
pce_dev->dst_nents = count_sg(areq->dst,
q_req->cryptlen);
qce_dma_map_sg(pce_dev->pdev, areq->dst, pce_dev->dst_nents,
DMA_FROM_DEVICE);
}
/* cipher iv for input */
if (pce_dev->ce_sps.minor_version != 0)
pce_dev->phy_iv_in = dma_map_single(pce_dev->pdev, q_req->iv,
ivsize, DMA_TO_DEVICE);
/* setup for callback, and issue command to bam */
pce_dev->areq = q_req->areq;
pce_dev->qce_cb = q_req->qce_cb;
/* Register callback event for EOT (End of transfer) event. */
pce_dev->ce_sps.producer.event.callback = <API key>;
pce_dev->ce_sps.producer.event.options = SPS_O_DESC_DONE;
rc = sps_register_event(pce_dev->ce_sps.producer.pipe,
&pce_dev->ce_sps.producer.event);
if (rc) {
pr_err("Producer callback registration failed rc = %d\n", rc);
goto bad;
}
<API key>(pce_dev);
if (pce_dev->support_cmd_dscr) {
_qce_sps_add_cmd(pce_dev, SPS_IOVEC_FLAG_LOCK, cmdlistinfo,
&pce_dev->ce_sps.in_transfer);
} else {
rc = <API key>(pce_dev, q_req, totallen,
areq->assoclen + ivsize);
if (rc)
goto bad;
}
if (pce_dev->ce_sps.minor_version == 0) {
if (<API key>(pce_dev, areq->src, totallen,
&pce_dev->ce_sps.in_transfer))
goto bad;
_qce_set_flag(&pce_dev->ce_sps.in_transfer,
SPS_IOVEC_FLAG_EOT|SPS_IOVEC_FLAG_NWD);
if (<API key>(pce_dev, areq->dst, totallen,
&pce_dev->ce_sps.out_transfer))
goto bad;
if (totallen > SPS_MAX_PKT_SIZE) {
_qce_set_flag(&pce_dev->ce_sps.out_transfer,
SPS_IOVEC_FLAG_INT);
pce_dev->ce_sps.producer.event.options =
SPS_O_DESC_DONE;
pce_dev->ce_sps.producer_state = QCE_PIPE_STATE_IDLE;
} else {
if (_qce_sps_add_data(GET_PHYS_ADDR(
pce_dev->ce_sps.result_dump),
<API key>,
&pce_dev->ce_sps.out_transfer))
goto bad;
_qce_set_flag(&pce_dev->ce_sps.out_transfer,
SPS_IOVEC_FLAG_INT);
pce_dev->ce_sps.producer_state = QCE_PIPE_STATE_COMP;
}
} else {
if (<API key>(pce_dev, areq->assoc, areq->assoclen,
&pce_dev->ce_sps.in_transfer))
goto bad;
if (_qce_sps_add_data((uint32_t)pce_dev->phy_iv_in, ivsize,
&pce_dev->ce_sps.in_transfer))
goto bad;
if (<API key>(pce_dev, areq->src, areq->cryptlen,
&pce_dev->ce_sps.in_transfer))
goto bad;
_qce_set_flag(&pce_dev->ce_sps.in_transfer,
SPS_IOVEC_FLAG_EOT|SPS_IOVEC_FLAG_NWD);
/* Pass through to ignore associated + iv data*/
if (_qce_sps_add_data(
GET_PHYS_ADDR(pce_dev->ce_sps.ignore_buffer),
(ivsize + areq->assoclen),
&pce_dev->ce_sps.out_transfer))
goto bad;
if (<API key>(pce_dev, areq->dst, areq->cryptlen,
&pce_dev->ce_sps.out_transfer))
goto bad;
if (totallen > SPS_MAX_PKT_SIZE) {
_qce_set_flag(&pce_dev->ce_sps.out_transfer,
SPS_IOVEC_FLAG_INT);
pce_dev->ce_sps.producer_state = QCE_PIPE_STATE_IDLE;
} else {
if (_qce_sps_add_data(
GET_PHYS_ADDR(pce_dev->ce_sps.result_dump),
<API key>,
&pce_dev->ce_sps.out_transfer))
goto bad;
_qce_set_flag(&pce_dev->ce_sps.out_transfer,
SPS_IOVEC_FLAG_INT);
pce_dev->ce_sps.producer_state = QCE_PIPE_STATE_COMP;
}
}
rc = _qce_sps_transfer(pce_dev);
if (rc)
goto bad;
return 0;
bad:
if (pce_dev->assoc_nents) {
qce_dma_unmap_sg(pce_dev->pdev, areq->assoc,
pce_dev->assoc_nents, DMA_TO_DEVICE);
}
if (pce_dev->src_nents) {
qce_dma_unmap_sg(pce_dev->pdev, areq->src, pce_dev->src_nents,
(areq->src == areq->dst) ? DMA_BIDIRECTIONAL :
DMA_TO_DEVICE);
}
if (areq->src != areq->dst) {
qce_dma_unmap_sg(pce_dev->pdev, areq->dst, pce_dev->dst_nents,
DMA_FROM_DEVICE);
}
if (pce_dev->phy_iv_in) {
dma_unmap_single(pce_dev->pdev, pce_dev->phy_iv_in,
ivsize, DMA_TO_DEVICE);
}
return rc;
}
EXPORT_SYMBOL(qce_aead_req);
int qce_ablk_cipher_req(void *handle, struct qce_req *c_req)
{
int rc = 0;
struct qce_device *pce_dev = (struct qce_device *) handle;
struct ablkcipher_request *areq = (struct ablkcipher_request *)
c_req->areq;
struct qce_cmdlist_info *cmdlistinfo = NULL;
pce_dev->src_nents = 0;
pce_dev->dst_nents = 0;
/* cipher input */
pce_dev->src_nents = count_sg(areq->src, areq->nbytes);
qce_dma_map_sg(pce_dev->pdev, areq->src, pce_dev->src_nents,
(areq->src == areq->dst) ? DMA_BIDIRECTIONAL :
DMA_TO_DEVICE);
/* cipher output */
if (areq->src != areq->dst) {
pce_dev->dst_nents = count_sg(areq->dst, areq->nbytes);
qce_dma_map_sg(pce_dev->pdev, areq->dst,
pce_dev->dst_nents, DMA_FROM_DEVICE);
} else {
pce_dev->dst_nents = pce_dev->src_nents;
}
pce_dev->dir = c_req->dir;
if ((pce_dev->ce_sps.minor_version == 0) && (c_req->dir == QCE_DECRYPT)
&& (c_req->mode == QCE_MODE_CBC)) {
memcpy(pce_dev->dec_iv, (unsigned char *)sg_virt(areq->src) +
areq->src->length - 16,
<API key> * CRYPTO_REG_SIZE);
}
/* set up crypto device */
if (pce_dev->support_cmd_dscr) {
<API key>(pce_dev, c_req, &cmdlistinfo);
rc = _ce_setup_cipher(pce_dev, c_req, areq->nbytes, 0,
cmdlistinfo);
} else {
rc = <API key>(pce_dev, c_req, areq->nbytes, 0);
}
if (rc < 0)
goto bad;
/* setup for client callback, and issue command to BAM */
pce_dev->areq = areq;
pce_dev->qce_cb = c_req->qce_cb;
/* Register callback event for EOT (End of transfer) event. */
pce_dev->ce_sps.producer.event.callback =
<API key>;
pce_dev->ce_sps.producer.event.options = SPS_O_DESC_DONE;
rc = sps_register_event(pce_dev->ce_sps.producer.pipe,
&pce_dev->ce_sps.producer.event);
if (rc) {
pr_err("Producer callback registration failed rc = %d\n", rc);
goto bad;
}
<API key>(pce_dev);
if (pce_dev->support_cmd_dscr)
_qce_sps_add_cmd(pce_dev, SPS_IOVEC_FLAG_LOCK, cmdlistinfo,
&pce_dev->ce_sps.in_transfer);
if (<API key>(pce_dev, areq->src, areq->nbytes,
&pce_dev->ce_sps.in_transfer))
goto bad;
_qce_set_flag(&pce_dev->ce_sps.in_transfer,
SPS_IOVEC_FLAG_EOT|SPS_IOVEC_FLAG_NWD);
if (<API key>(pce_dev, areq->dst, areq->nbytes,
&pce_dev->ce_sps.out_transfer))
goto bad;
if (areq->nbytes > SPS_MAX_PKT_SIZE) {
_qce_set_flag(&pce_dev->ce_sps.out_transfer,
SPS_IOVEC_FLAG_INT);
pce_dev->ce_sps.producer_state = QCE_PIPE_STATE_IDLE;
} else {
pce_dev->ce_sps.producer_state = QCE_PIPE_STATE_COMP;
if (_qce_sps_add_data(
GET_PHYS_ADDR(pce_dev->ce_sps.result_dump),
<API key>,
&pce_dev->ce_sps.out_transfer))
goto bad;
_qce_set_flag(&pce_dev->ce_sps.out_transfer,
SPS_IOVEC_FLAG_INT);
}
rc = _qce_sps_transfer(pce_dev);
if (rc)
goto bad;
return 0;
bad:
if (areq->src != areq->dst) {
if (pce_dev->dst_nents) {
qce_dma_unmap_sg(pce_dev->pdev, areq->dst,
pce_dev->dst_nents, DMA_FROM_DEVICE);
}
}
if (pce_dev->src_nents) {
qce_dma_unmap_sg(pce_dev->pdev, areq->src,
pce_dev->src_nents,
(areq->src == areq->dst) ?
DMA_BIDIRECTIONAL : DMA_TO_DEVICE);
}
return rc;
}
EXPORT_SYMBOL(qce_ablk_cipher_req);
int qce_process_sha_req(void *handle, struct qce_sha_req *sreq)
{
struct qce_device *pce_dev = (struct qce_device *) handle;
int rc;
struct ahash_request *areq = (struct ahash_request *)sreq->areq;
struct qce_cmdlist_info *cmdlistinfo = NULL;
pce_dev->src_nents = count_sg(sreq->src, sreq->size);
qce_dma_map_sg(pce_dev->pdev, sreq->src, pce_dev->src_nents,
DMA_TO_DEVICE);
if (pce_dev->support_cmd_dscr) {
<API key>(pce_dev, sreq, &cmdlistinfo);
rc = _ce_setup_hash(pce_dev, sreq, cmdlistinfo);
} else {
rc = <API key>(pce_dev, sreq);
}
if (rc < 0)
goto bad;
pce_dev->areq = areq;
pce_dev->qce_cb = sreq->qce_cb;
/* Register callback event for EOT (End of transfer) event. */
pce_dev->ce_sps.producer.event.callback = <API key>;
pce_dev->ce_sps.producer.event.options = SPS_O_DESC_DONE;
rc = sps_register_event(pce_dev->ce_sps.producer.pipe,
&pce_dev->ce_sps.producer.event);
if (rc) {
pr_err("Producer callback registration failed rc = %d\n", rc);
goto bad;
}
<API key>(pce_dev);
if (pce_dev->support_cmd_dscr)
_qce_sps_add_cmd(pce_dev, SPS_IOVEC_FLAG_LOCK, cmdlistinfo,
&pce_dev->ce_sps.in_transfer);
if (<API key>(pce_dev, areq->src, areq->nbytes,
&pce_dev->ce_sps.in_transfer))
goto bad;
_qce_set_flag(&pce_dev->ce_sps.in_transfer,
SPS_IOVEC_FLAG_EOT|SPS_IOVEC_FLAG_NWD);
if (_qce_sps_add_data(GET_PHYS_ADDR(pce_dev->ce_sps.result_dump),
<API key>,
&pce_dev->ce_sps.out_transfer))
goto bad;
_qce_set_flag(&pce_dev->ce_sps.out_transfer, SPS_IOVEC_FLAG_INT);
rc = _qce_sps_transfer(pce_dev);
if (rc)
goto bad;
return 0;
bad:
if (pce_dev->src_nents) {
qce_dma_unmap_sg(pce_dev->pdev, sreq->src,
pce_dev->src_nents, DMA_TO_DEVICE);
}
return rc;
}
EXPORT_SYMBOL(qce_process_sha_req);
static int <API key>(struct platform_device *pdev,
struct qce_device *pce_dev)
{
struct resource *resource;
int rc = 0;
pce_dev->is_shared = <API key>((&pdev->dev)->of_node,
"qcom,ce-hw-shared");
pce_dev->support_hw_key = <API key>((&pdev->dev)->of_node,
"qcom,ce-hw-key");
if (<API key>((&pdev->dev)->of_node,
"qcom,bam-pipe-pair",
&pce_dev->ce_sps.pipe_pair_index)) {
pr_err("Fail to get bam pipe pair information.\n");
return -EINVAL;
} else {
pr_warn("bam_pipe_pair=0x%x", pce_dev->ce_sps.pipe_pair_index);
}
pce_dev->ce_sps.dest_pipe_index = 2 * pce_dev->ce_sps.pipe_pair_index;
pce_dev->ce_sps.src_pipe_index = pce_dev->ce_sps.dest_pipe_index + 1;
resource = <API key>(pdev, IORESOURCE_MEM,
"crypto-base");
if (resource) {
pce_dev->phy_iobase = resource->start;
pce_dev->iobase = ioremap_nocache(resource->start,
resource_size(resource));
if (!pce_dev->iobase) {
pr_err("Can not map CRYPTO io memory\n");
return -ENOMEM;
}
} else {
pr_err("CRYPTO HW mem unavailable.\n");
return -ENODEV;
}
pr_warn("ce_phy_reg_base=0x%x ", pce_dev->phy_iobase);
pr_warn("ce_virt_reg_base=0x%x\n", (uint32_t)pce_dev->iobase);
resource = <API key>(pdev, IORESOURCE_MEM,
"crypto-bam-base");
if (resource) {
pce_dev->ce_sps.bam_mem = resource->start;
pce_dev->ce_sps.bam_iobase = ioremap_nocache(resource->start,
resource_size(resource));
if (!pce_dev->ce_sps.bam_iobase) {
rc = -ENOMEM;
pr_err("Can not map BAM io memory\n");
goto <API key>;
}
} else {
pr_err("CRYPTO BAM mem unavailable.\n");
rc = -ENODEV;
goto <API key>;
}
pr_warn("ce_bam_phy_reg_base=0x%x ", pce_dev->ce_sps.bam_mem);
pr_warn("<API key>=0x%x\n",
(uint32_t)pce_dev->ce_sps.bam_iobase);
resource = <API key>(pdev, IORESOURCE_IRQ, 0);
if (resource) {
pce_dev->ce_sps.bam_irq = resource->start;
pr_warn("CRYPTO BAM IRQ = %d.\n", pce_dev->ce_sps.bam_irq);
} else {
pr_err("CRYPTO BAM IRQ unavailable.\n");
goto err_dev;
}
return rc;
err_dev:
if (pce_dev->ce_sps.bam_iobase)
iounmap(pce_dev->ce_sps.bam_iobase);
<API key>:
if (pce_dev->iobase)
iounmap(pce_dev->iobase);
return rc;
}
static int __qce_init_clk(struct qce_device *pce_dev)
{
int rc = 0;
struct clk *ce_core_clk;
struct clk *ce_clk;
struct clk *ce_core_src_clk;
struct clk *ce_bus_clk;
/* Get CE3 src core clk. */
ce_core_src_clk = clk_get(pce_dev->pdev, "core_clk_src");
if (!IS_ERR(ce_core_src_clk)) {
pce_dev->ce_core_src_clk = ce_core_src_clk;
/* Set the core src clk @100Mhz */
rc = clk_set_rate(pce_dev->ce_core_src_clk, 100000000);
if (rc) {
clk_put(pce_dev->ce_core_src_clk);
pce_dev->ce_core_src_clk = NULL;
pr_err("Unable to set the core src clk @100Mhz.\n");
goto err_clk;
}
} else {
pr_warn("Unable to get CE core src clk, set to NULL\n");
pce_dev->ce_core_src_clk = NULL;
}
/* Get CE core clk */
ce_core_clk = clk_get(pce_dev->pdev, "core_clk");
if (IS_ERR(ce_core_clk)) {
rc = PTR_ERR(ce_core_clk);
pr_err("Unable to get CE core clk\n");
if (pce_dev->ce_core_src_clk != NULL)
clk_put(pce_dev->ce_core_src_clk);
goto err_clk;
}
pce_dev->ce_core_clk = ce_core_clk;
/* Get CE Interface clk */
ce_clk = clk_get(pce_dev->pdev, "iface_clk");
if (IS_ERR(ce_clk)) {
rc = PTR_ERR(ce_clk);
pr_err("Unable to get CE interface clk\n");
if (pce_dev->ce_core_src_clk != NULL)
clk_put(pce_dev->ce_core_src_clk);
clk_put(pce_dev->ce_core_clk);
goto err_clk;
}
pce_dev->ce_clk = ce_clk;
/* Get CE AXI clk */
ce_bus_clk = clk_get(pce_dev->pdev, "bus_clk");
if (IS_ERR(ce_bus_clk)) {
rc = PTR_ERR(ce_bus_clk);
pr_err("Unable to get CE BUS interface clk\n");
if (pce_dev->ce_core_src_clk != NULL)
clk_put(pce_dev->ce_core_src_clk);
clk_put(pce_dev->ce_core_clk);
clk_put(pce_dev->ce_clk);
goto err_clk;
}
pce_dev->ce_bus_clk = ce_bus_clk;
err_clk:
if (rc)
pr_err("Unable to init CE clks, rc = %d\n", rc);
return rc;
}
static void __qce_deinit_clk(struct qce_device *pce_dev)
{
if (pce_dev->ce_clk != NULL) {
clk_put(pce_dev->ce_clk);
pce_dev->ce_clk = NULL;
}
if (pce_dev->ce_core_clk != NULL) {
clk_put(pce_dev->ce_core_clk);
pce_dev->ce_core_clk = NULL;
}
if (pce_dev->ce_bus_clk != NULL) {
clk_put(pce_dev->ce_bus_clk);
pce_dev->ce_bus_clk = NULL;
}
if (pce_dev->ce_core_src_clk != NULL) {
clk_put(pce_dev->ce_core_src_clk);
pce_dev->ce_core_src_clk = NULL;
}
}
int qce_enable_clk(void *handle)
{
struct qce_device *pce_dev = (struct qce_device *) handle;
int rc = 0;
/* Enable CE core clk */
if (pce_dev->ce_core_clk != NULL) {
rc = clk_prepare_enable(pce_dev->ce_core_clk);
if (rc) {
pr_err("Unable to enable/prepare CE core clk\n");
return rc;
}
}
/* Enable CE clk */
if (pce_dev->ce_clk != NULL) {
rc = clk_prepare_enable(pce_dev->ce_clk);
if (rc) {
pr_err("Unable to enable/prepare CE iface clk\n");
<API key>(pce_dev->ce_core_clk);
return rc;
}
}
/* Enable AXI clk */
if (pce_dev->ce_bus_clk != NULL) {
rc = clk_prepare_enable(pce_dev->ce_bus_clk);
if (rc) {
pr_err("Unable to enable/prepare CE BUS clk\n");
<API key>(pce_dev->ce_clk);
<API key>(pce_dev->ce_core_clk);
return rc;
}
}
return rc;
}
EXPORT_SYMBOL(qce_enable_clk);
int qce_disable_clk(void *handle)
{
struct qce_device *pce_dev = (struct qce_device *) handle;
int rc = 0;
if (pce_dev->ce_clk != NULL)
<API key>(pce_dev->ce_clk);
if (pce_dev->ce_core_clk != NULL)
<API key>(pce_dev->ce_core_clk);
if (pce_dev->ce_bus_clk != NULL)
<API key>(pce_dev->ce_bus_clk);
return rc;
}
EXPORT_SYMBOL(qce_disable_clk);
/* crypto engine open function. */
void *qce_open(struct platform_device *pdev, int *rc)
{
struct qce_device *pce_dev;
uint32_t bam_cfg = 0 ;
pce_dev = kzalloc(sizeof(struct qce_device), GFP_KERNEL);
if (!pce_dev) {
*rc = -ENOMEM;
pr_err("Can not allocate memory: %d\n", *rc);
return NULL;
}
pce_dev->pdev = &pdev->dev;
if (pdev->dev.of_node) {
*rc = <API key>(pdev, pce_dev);
if (*rc)
goto err_pce_dev;
} else {
*rc = -EINVAL;
pr_err("Device Node not found.\n");
goto err_pce_dev;
}
pce_dev->memsize = 9 * PAGE_SIZE;
pce_dev->coh_vmem = dma_alloc_coherent(pce_dev->pdev,
pce_dev->memsize, &pce_dev->coh_pmem, GFP_KERNEL);
if (pce_dev->coh_vmem == NULL) {
*rc = -ENOMEM;
pr_err("Can not allocate coherent memory for sps data\n");
goto err_iobase;
}
*rc = __qce_init_clk(pce_dev);
if (*rc)
goto err_mem;
*rc = qce_enable_clk(pce_dev);
if (*rc)
goto err;
if (_probe_ce_engine(pce_dev)) {
*rc = -ENXIO;
goto err;
}
*rc = 0;
bam_cfg = readl_relaxed(pce_dev->ce_sps.bam_iobase +
<API key>);
pce_dev->support_cmd_dscr = (bam_cfg & <API key>) ?
true : false;
qce_init_ce_cfg_val(pce_dev);
<API key>(pce_dev);
qce_sps_init(pce_dev);
qce_disable_clk(pce_dev);
return pce_dev;
err:
__qce_deinit_clk(pce_dev);
err_mem:
if (pce_dev->coh_vmem)
dma_free_coherent(pce_dev->pdev, pce_dev->memsize,
pce_dev->coh_vmem, pce_dev->coh_pmem);
err_iobase:
if (pce_dev->ce_sps.bam_iobase)
iounmap(pce_dev->ce_sps.bam_iobase);
if (pce_dev->iobase)
iounmap(pce_dev->iobase);
err_pce_dev:
kfree(pce_dev);
return NULL;
}
EXPORT_SYMBOL(qce_open);
/* crypto engine close function. */
int qce_close(void *handle)
{
struct qce_device *pce_dev = (struct qce_device *) handle;
if (handle == NULL)
return -ENODEV;
qce_enable_clk(pce_dev);
qce_sps_exit(pce_dev);
if (pce_dev->iobase)
iounmap(pce_dev->iobase);
if (pce_dev->coh_vmem)
dma_free_coherent(pce_dev->pdev, pce_dev->memsize,
pce_dev->coh_vmem, pce_dev->coh_pmem);
qce_disable_clk(pce_dev);
__qce_deinit_clk(pce_dev);
kfree(handle);
return 0;
}
EXPORT_SYMBOL(qce_close);
int qce_hw_support(void *handle, struct ce_hw_support *ce_support)
{
struct qce_device *pce_dev = (struct qce_device *)handle;
if (ce_support == NULL)
return -EINVAL;
ce_support->sha1_hmac_20 = false;
ce_support->sha1_hmac = false;
ce_support->sha256_hmac = false;
ce_support->sha_hmac = true;
ce_support->cmac = true;
ce_support->aes_key_192 = false;
ce_support->aes_xts = true;
ce_support->ota = false;
ce_support->bam = true;
ce_support->is_shared = (pce_dev->is_shared == 1) ? true : false;
ce_support->hw_key = pce_dev->support_hw_key;
ce_support->aes_ccm = true;
if (pce_dev->ce_sps.minor_version)
ce_support->aligned_only = false;
else
ce_support->aligned_only = true;
return 0;
}
EXPORT_SYMBOL(qce_hw_support);
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("Crypto Engine driver");
|
package org.zanata.dao;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Restrictions;
import org.jboss.seam.ScopeType;
import org.jboss.seam.annotations.AutoCreate;
import org.jboss.seam.annotations.Name;
import org.jboss.seam.annotations.Scope;
import org.zanata.model.HAccount;
import org.zanata.model.HAccountRole;
import org.zanata.model.HProject;
@Name("accountRoleDAO")
@AutoCreate
@Scope(ScopeType.STATELESS)
public class AccountRoleDAO extends AbstractDAOImpl<HAccountRole, Integer> {
public AccountRoleDAO() {
super(HAccountRole.class);
}
public AccountRoleDAO(Session session) {
super(HAccountRole.class, session);
}
public boolean roleExists(String role) {
return findByName(role) != null;
}
public HAccountRole findByName(String roleName) {
Criteria cr = getSession().createCriteria(HAccountRole.class);
cr.add(Restrictions.eq("name", roleName));
cr.setCacheable(true).setComment("AccountRoleDAO.findByName");
return (HAccountRole) cr.uniqueResult();
}
public HAccountRole create(String roleName, HAccountRole.RoleType type,
String... includesRoles) {
HAccountRole role = new HAccountRole();
role.setName(roleName);
role.setRoleType(type);
for (String includeRole : includesRoles) {
Set<HAccountRole> groups = role.getGroups();
if (groups == null) {
groups = new HashSet<HAccountRole>();
role.setGroups(groups);
}
groups.add(findByName(includeRole));
}
makePersistent(role);
return role;
}
public HAccountRole updateIncludeRoles(String roleName,
String... includesRoles) {
HAccountRole role = findByName(roleName);
for (String includeRole : includesRoles) {
Set<HAccountRole> groups = role.getGroups();
if (groups == null) {
groups = new HashSet<HAccountRole>();
role.setGroups(groups);
}
groups.add(findByName(includeRole));
}
makePersistent(role);
return role;
}
public List<HAccount> listMembers(String roleName) {
HAccountRole role = findByName(roleName);
return listMembers(role);
}
@SuppressWarnings("unchecked")
public List<HAccount> listMembers(HAccountRole role) {
Query query =
getSession()
.createQuery(
"from HAccount account where :role member of account.roles");
query.setParameter("role", role);
query.setComment("AccountRoleDAO.listMembers");
return query.list();
}
public Collection<HAccountRole> getByProject(HProject project) {
return getSession()
.createQuery(
"select p.allowedRoles from HProject p where p = :project")
.setParameter("project", project)
.setComment("AccountRoleDAO.getByProject").list();
}
}
|
/**
* @file
* Formula debugger - implementation
* */
#include "formula_debugger.hpp"
#include "formula.hpp"
#include "formula_function.hpp"
#include "game_display.hpp"
#include "log.hpp"
#include "resources.hpp"
#include "gui/dialogs/formula_debugger.hpp"
#include "gui/widgets/settings.hpp"
#include <boost/lexical_cast.hpp>
static lg::log_domain <API key>("ai/debug/formula");
#define DBG_FDB LOG_STREAM(debug, <API key>)
#define LOG_FDB LOG_STREAM(info, <API key>)
#define WRN_FDB LOG_STREAM(warn, <API key>)
#define ERR_FDB LOG_STREAM(err, <API key>)
namespace game_logic {
debug_info::debug_info(int arg_number, int counter, int level, const std::string &name, const std::string &str, const variant &value, bool evaluated)
: arg_number_(arg_number), counter_(counter), level_(level), name_(name), str_(str), value_(value), evaluated_(evaluated)
{
}
debug_info::~debug_info()
{
}
int debug_info::level() const
{
return level_;
}
const std::string& debug_info::name() const
{
return name_;
}
int debug_info::counter() const
{
return counter_;
}
const variant& debug_info::value() const
{
return value_;
}
void debug_info::set_value(const variant &value)
{
value_ = value;
}
bool debug_info::evaluated() const
{
return evaluated_;
}
void debug_info::set_evaluated(bool evaluated)
{
evaluated_ = evaluated;
}
const std::string& debug_info::str() const
{
return str_;
}
formula_debugger::formula_debugger()
: call_stack_(), counter_(0), current_breakpoint_(), breakpoints_(), execution_trace_(),<API key>(-1), <API key>("")
{
<API key>();
<API key>();
}
formula_debugger::~formula_debugger()
{
}
static void msg(const char *act, debug_info &i, const char *to="", const char *result = "")
{
DBG_FDB << "#" << i.counter() << act << std::endl <<" \""<< i.name().c_str() << "\"='" << i.str().c_str() << "' " << to << result << std::endl;
}
void formula_debugger::add_debug_info(int arg_number, const char *f_name)
{
<API key> = arg_number;
<API key> = f_name;
}
const std::deque<debug_info>& formula_debugger::get_call_stack() const
{
return call_stack_;
}
const breakpoint_ptr formula_debugger::<API key>() const
{
return current_breakpoint_;
}
const std::deque<debug_info>& formula_debugger::get_execution_trace() const
{
return execution_trace_;
}
void formula_debugger::check_breakpoints()
{
for( std::deque< breakpoint_ptr >::iterator b = breakpoints_.begin(); b!= breakpoints_.end(); ++b) {
if ((*b)->is_break_now()){
current_breakpoint_ = (*b);
show_gui();
current_breakpoint_ = breakpoint_ptr();
if ((*b)->is_one_time_only()) {
breakpoints_.erase(b);
}
break;
}
}
}
void formula_debugger::show_gui()
{
if (resources::screen == NULL) {
WRN_FDB << "do not showing debug window due to NULL gui" << std::endl;
return;
}
if (gui2::new_widgets) {
gui2::tformula_debugger debug_dialog(*this);
debug_dialog.show(resources::screen->video());
} else {
WRN_FDB << "do not showing debug window due to disabled --new-widgets"<< std::endl;
}
}
void formula_debugger::call_stack_push(const std::string &str)
{
call_stack_.push_back(debug_info(<API key>,counter_++,call_stack_.size(),<API key>,str,variant(),false));
<API key> = -1;
<API key> = "";
execution_trace_.push_back(call_stack_.back());
}
void formula_debugger::call_stack_pop()
{
execution_trace_.push_back(call_stack_.back());
call_stack_.pop_back();
}
void formula_debugger::<API key>(bool evaluated)
{
call_stack_.back().set_evaluated(evaluated);
}
void formula_debugger::<API key>(const variant &v)
{
call_stack_.back().set_value(v);
}
variant formula_debugger::<API key>(const formula_expression &expression, const formula_callable &variables)
{
call_stack_push(expression.str());
check_breakpoints();
msg(" evaluating expression: ",call_stack_.back());
variant v = expression.execute(variables,this);
<API key>(v);
<API key>(true);
msg(" evaluated expression: ",call_stack_.back()," to ",v.to_debug_string(NULL,true).c_str());
check_breakpoints();
call_stack_pop();
return v;
}
variant formula_debugger::<API key>(const formula &f, const formula_callable &variables)
{
call_stack_push(f.str());
check_breakpoints();
msg(" evaluating formula: ",call_stack_.back());
variant v = f.execute(variables,this);
<API key>(v);
<API key>(true);
msg(" evaluated formula: ",call_stack_.back()," to ",v.to_debug_string(NULL,true).c_str());
check_breakpoints();
call_stack_pop();
return v;
}
variant formula_debugger::<API key>(const formula &f)
{
call_stack_push(f.str());
check_breakpoints();
msg(" evaluating formula without variables: ",call_stack_.back());
variant v = f.execute(this);
<API key>(v);
<API key>(true);
msg(" evaluated formula without variables: ",call_stack_.back()," to ",v.to_debug_string(NULL,true).c_str());
check_breakpoints();
call_stack_pop();
return v;
}
base_breakpoint::base_breakpoint(formula_debugger &fdb, const std::string &name, bool one_time_only)
: fdb_(fdb), name_(name), one_time_only_(one_time_only)
{
}
base_breakpoint::~base_breakpoint()
{
}
bool base_breakpoint::is_one_time_only() const
{
return one_time_only_;
}
const std::string& base_breakpoint::name() const
{
return name_;
}
class end_breakpoint : public base_breakpoint {
public:
end_breakpoint(formula_debugger &fdb)
: base_breakpoint(fdb,"End", true)
{
}
virtual ~end_breakpoint()
{
}
virtual bool is_break_now() const
{
const std::deque<debug_info> &call_stack = fdb_.get_call_stack();
if ((call_stack.size() == 1) && (call_stack[0].evaluated()) ) {
return true;
}
return false;
}
};
class step_in_breakpoint : public base_breakpoint {
public:
step_in_breakpoint(formula_debugger &fdb)
: base_breakpoint(fdb,"Step",true)
{
}
virtual ~step_in_breakpoint()
{
}
virtual bool is_break_now() const
{
const std::deque<debug_info> &call_stack = fdb_.get_call_stack();
if (call_stack.empty() || call_stack.back().evaluated()) {
return false;
}
return true;
}
};
class step_out_breakpoint : public base_breakpoint {
public:
step_out_breakpoint(formula_debugger &fdb)
: base_breakpoint(fdb,"Step out",true), level_(fdb.get_call_stack().size()-1)
{
}
virtual ~step_out_breakpoint()
{
}
virtual bool is_break_now() const
{
const std::deque<debug_info> &call_stack = fdb_.get_call_stack();
if (call_stack.empty() || call_stack.back().evaluated()) {
return false;
}
if (call_stack.size() == level_) {
return true;
}
return false;
}
private:
size_t level_;
};
class next_breakpoint : public base_breakpoint {
public:
next_breakpoint(formula_debugger &fdb)
: base_breakpoint(fdb,"Next",true), level_(fdb.get_call_stack().size())
{
}
virtual ~next_breakpoint()
{
}
virtual bool is_break_now() const
{
const std::deque<debug_info> &call_stack = fdb_.get_call_stack();
if (call_stack.empty() || call_stack.back().evaluated()) {
return false;
}
if (call_stack.size() == level_) {
return true;
}
return false;
}
private:
size_t level_;
};
void formula_debugger::<API key>()
{
breakpoints_.push_back(breakpoint_ptr(new end_breakpoint(*this)));
LOG_FDB << "added 'end' breakpoint"<< std::endl;
}
void formula_debugger::<API key>()
{
breakpoints_.push_back(breakpoint_ptr(new step_in_breakpoint(*this)));
LOG_FDB << "added 'step into' breakpoint"<< std::endl;
}
void formula_debugger::<API key>()
{
breakpoints_.push_back(breakpoint_ptr(new step_out_breakpoint(*this)));
LOG_FDB << "added 'step out' breakpoint"<< std::endl;
}
void formula_debugger::add_breakpoint_next()
{
breakpoints_.push_back(breakpoint_ptr(new next_breakpoint(*this)));
LOG_FDB << "added 'next' breakpoint"<< std::endl;
}
} // end of namespace game_logic
|
#include "botpch.h"
#include "../../playerbot.h"
#include "BuyAction.h"
#include "../ItemVisitors.h"
#include "../values/ItemCountValue.h"
using namespace ai;
bool BuyAction::Execute(Event event)
{
string link = event.getParam();
ItemIds itemIds = chat->parseItems(link);
if (itemIds.empty())
return false;
Player* master = GetMaster();
if (!master)
return false;
ObjectGuid vendorguid = master->GetSelectionGuid();
if (!vendorguid)
return false;
Creature *pCreature = bot-><API key>(vendorguid,<API key>);
if (!pCreature)
{
ai->TellMaster("Cannot talk to vendor");
return false;
}
VendorItemData const* tItems = pCreature->GetVendorItems();
if (!tItems)
{
ai->TellMaster("This vendor has no items");
return false;
}
for (ItemIds::iterator i = itemIds.begin(); i != itemIds.end(); i++)
{
for (uint32 slot = 0; slot < tItems->GetItemCount(); slot++)
{
if (tItems->GetItem(slot)->item == *i)
{
bot->BuyItemFromVendor(vendorguid, *i, 1, NULL_BAG, NULL_SLOT);
ai->TellMaster("Bought item");
}
}
}
return true;
}
|
<!DOCTYPE html PUBLIC "-
<html xmlns="http:
<?php
defined( '_JEXEC' ) or die( 'Restricted access' );
if(!defined('DS')){define('DS',DIRECTORY_SEPARATOR);}
$tcParams = '';
include_once(dirname(__FILE__).DS.'tclibs'.DS.'head.php');
include_once(dirname(__FILE__).DS.'tclibs'.DS.'settings.php');
$tcParams .= '<body id="tc">';
$tcParams .= TCShowModule('adverts', 'mx_xhtml', 'container');
$tcParams .= '<div id="mx_wrapper" class="mx_wrapper">';
$tcParams .= TCShowModule('header', 'mx_xhtml', 'container');
$tcParams .= '<jdoc:include type="modules" name="sign_in" />';
include_once(dirname(__FILE__).DS.'tclibs'.DS.'slider.php');
include_once(dirname(__FILE__).DS.'tclibs'.DS.'social.php');
$tcParams .= TCShowModule('slider', 'mx_xhtml', 'container');
$tcParams .= TCShowModule('top', 'mx_xhtml', 'container');
$tcParams .= TCShowModule('info', 'mx_xhtml', 'container');
$tcParams .= '<section class="mx_wrapper_info mx_section">'
.'<div class="container mx_group"><jdoc:include type="modules" name="search_jobs_box" />'
// .'<div><jdoc:include type="modules" name="test1" /></div>'
.'</div></section>';
//Latest Jobs blocks
$tcParams .= '<div class="row"><jdoc:include type="modules" name="latest_jobs" /></div>'
;
//Slide top
$tcParams .= '<section class="mx_wrapper_top mx_section">'
.'<div class="container mx_group">'
.'<jdoc:include type="modules" name="top_slide" />'
.'</div></section>';
//very maintop content block
$tcParams .= '<section class="mx_wrapper_maintop mx_section">'
.'<div class="container mx_group">'
.'<jdoc:include type="modules" name="top_block" />'
.'</div></section>';
$tcParams .= TCShowModule('maintop', 'mx_xhtml', 'container');
$tcParams .= '<main class="mx_main container clearfix">'.$component.'</main>';
$tcParams .= TCShowModule('mainbottom', 'mx_xhtml', 'container').
TCShowModule('feature', 'mx_xhtml', 'container').
TCShowModule('bottom', 'mx_xhtml', 'container').
TCShowModule('footer', 'mx_xhtml', 'container');
//Advise widget
$tcParams .= '<div class="row">'
.'<jdoc:include type="modules" name="advise-widget" />'
.'</div>';
//Resume nav bar
$tcParams .= '<div class="mod-content clearfix">'
.'<jdoc:include type="modules" name="Create_ResumeNavBar" />'
.'</div>';
//Feature blocks
$tcParams .= '<section class="mx_wrapper_feature mx_section">'
.'<div class="container mx_group">'
.'<jdoc:include type="modules" name="feature-1" />'
.'</div></section>';
//Footer blocks
$tcParams .= '<section class="mx_wrapper_bottom mx_section">'
.'<div class="container mx_group">'
.'<jdoc:include type="modules" name="footer_block" />'
.'</div></section>';
$tcParams .= '<footer class="<API key> mx_section">'.
'<div class="container clearfix">'.
'<div class="col-md-12">'.($copyright ? '<div style="padding:10px;">'.$cpright.' </div>' : ''). //'<div style="padding-bottom:10px; text-align:right; ">Designed by <a href="http://www.mixwebtemplates.com/" title="Visit mixwebtemplates.com!" target="blank">mixwebtemplates.com</a></div>'.
'</div>'.
'</div>'.
'</footer>';
$tcParams .='</div>';
include_once(dirname(__FILE__).DS.'tclibs'.DS.'debug.php');
$tcParams .='</body>';
$tcParams .='</html>';
echo $tcParams;
?>
|
#include "common.h"
extern "C" {
#include "perm.h"
}
/**
* \brief Print application help
*/
void printHelp() {
cout << "diffExprpermutation: Find differentially expressed genes from a set of control and cases samples using a permutation strategy." << endl;
cout << "diffExprPermutation -f input [--c1 condition1 --c2 condition2 -n permutations -H stopHits -s statistic] -o outFile" << endl;
cout << "Inputs:" << endl;
cout << " -f input Space separated table. Format: sampleName group lib.size norm.factors gene1 gene2 ... geneN" << endl;
cout << "Outputs:" << endl;
cout << " -o outFile Output file name" << endl;
cout << "Options:" << endl;
cout << " --c1 condition1 Condition that determine one of two groups [default: case]" << endl;
cout << " --c2 condition2 Condition that determine other group [default: control]" << endl;
cout << " -s statistic Statistic to compute pvalue median|perc25|perc75|x [default: median]" << endl;
cout << " -p percentile mode Mode for selection of percentile auto|linear|nearest [default: auto]" << endl;
cout << " -t n_threads Number of threads [default: 1]" << endl;
}
/**
* \brief Check Arguments
* \param string fileInput - Name input file
* \param string outFile - Name output file
* \param unsigned int chunks - Number of chunks to create
* \param string condition1 - First condition group. Usually case.
* \param string condition1 - Second condition group. Usually control.
*/
inline bool argumentChecking(const string &fileInput,
const string &outFile,
const string &condition1,
const string &condition2)
{
bool bWrong = false;
if (fileInput.empty())
{
cout << "Sorry!! No input file was specified!!" << endl;
return true;
}
if (outFile.empty())
{
cout << "Sorry!! No output file was specified!!" << endl;
return true;
}
if (condition1.empty())
{
cout << "Sorry!! Condition group 1 is empty!!" << endl;
return true;
}
if (condition2.empty())
{
cout << "Sorry!! Condition group 2 is empty!!" << endl;
return true;
}
return bWrong;
}
int main(int argc, char **argv)
{
string fileInput = "";
string outFile = "";
string condition1 = "case";
string condition2 = "control";
string percentile_mode = "auto";
cp_mode pc_mode = AUTO;
int n_threads = 1;
string statistic = "median";
double fStatisticValue = 0;
bool doMedian = true;
vector<Gene> vGenes; // vector of genes where each gene has a vector of sampleGenes, each sampleGene contains sample name expression value and group
/**
* BRACA1 -> A,true,0.75
* -> B,false,0.85
* ...
* BRACA2 -> A,true,0.15
* -> B,false,0.20
* ...
*/
// 1.Process parameters
for (int i = 1; i < argc; i++)
{
if (strcmp(argv[i], "-f") == 0)
{
fileInput = argv[++i];
}
else if (strcmp(argv[i], "-o") == 0)
{
outFile = argv[++i];
}
else if (strcmp(argv[i], "--c1") == 0)
{
condition1 = argv[++i];
}
else if (strcmp(argv[i], "--c2") == 0)
{
condition2 = argv[++i];
}
else if (strcmp(argv[i], "-s") == 0)
{
statistic = argv[++i];
}
else if (strcmp(argv[i], "-p") == 0)
{
percentile_mode = argv[++i];
}
else if (strcmp(argv[i], "-t") == 0)
{
n_threads = atoi(argv[++i]);
if (n_threads < 1) n_threads = 1;
}
else if (strcmp(argv[i],"-h") == 0)
{
printHelp();
return 0;
}
}
// Check Arguments
if(argumentChecking(fileInput, outFile, condition1, condition2))
{
return -1;
}
// Updates statistic
string headerOutput = "gene\tdiff_median\tmedianCase\tmedianControl\tfold_change\tmedian_pv\tmedian_pv_fdr";
if (statistic.compare("perc25") == 0)
{
fStatisticValue = 25.0;
doMedian = false;
headerOutput = "gene\tdiff_lowerq\tlowerqCase\tlowerqControl\tfold_change\tlowerq_pv\tlowerq_pv_fdr";
}
else if (statistic.compare("perc75") == 0)
{
fStatisticValue = 75.0;
doMedian = false;
headerOutput = "gene\tdiff_UpQ\tupperqCase\tupperqControl\tfold_change\tupperq_pv\tupper_pv_fdr";
}
else
{
char *p;
double x = strtod(statistic.c_str(), &p);
if (x > 0.0 && x < 100.0)
{
fStatisticValue = x;
doMedian = false;
ostringstream s;
s << "gene\tdiff_" << x << "%\t" << x << "\%_Case\t" << x << "\%_Control\tfold_change\t" << x << "\%_pv\t" << x << "\%_pv_fdr";
headerOutput = s.str();
}
}
if (percentile_mode.compare("auto") == 0) pc_mode = AUTO;
else if (percentile_mode.compare("linear") == 0) pc_mode = <API key>;
else if (percentile_mode.compare("nearest") == 0) pc_mode = NEAREST_RANK;
else
{
cerr << "Percentile mode '" << percentile_mode << "' not recognized" << endl;
return -1;
}
// Parsing Input file
if (!loadFileInfo(fileInput, vGenes, condition1, condition2))
{
cerr << "Sorry!! Can not open file " << fileInput << endl;
return -1;
}
// Allocate and make C structure for permutation routine
struct perm_data pdata;
pdata.n_cases = vGenes.begin()->nCases;
pdata.n_controls = vGenes.begin()->nControls;
int n_samples = pdata.n_cases + pdata.n_controls;
pdata.n_var = vGenes.size();
pdata.data = (float *)malloc(sizeof(float) * pdata.n_var * (4 + n_samples));
pdata.fold_change = pdata.data + pdata.n_var * n_samples;
pdata.pc_cases = pdata.fold_change + pdata.n_var;
pdata.pc_controls = pdata.pc_cases + pdata.n_var;
pdata.pc_diff = pdata.pc_controls + pdata.n_var;
pdata.grp = (group *)malloc(sizeof(group) * n_samples);
pdata.p_values = (double *)malloc(sizeof(double) * pdata.n_var);
// Copy expression data
float *tp = pdata.data;
for (vector<Gene>::iterator gene_it = vGenes.begin(); gene_it != vGenes.end(); ++gene_it)
{
for (vector<SampleGene>::const_iterator iter = gene_it->vGeneValues.begin();iter != gene_it->vGeneValues.end(); ++iter)
{
(*tp++) = (float)iter->expressionValue;
}
}
// Copy group information
int ix = 0;
for (vector<bool>::const_iterator iter = vGenes.begin()->vGroup.begin(); iter != vGenes.begin()->vGroup.end(); ++iter)
{
pdata.grp[ix++] = *iter ? CASE : CONTROL;
}
// Calculate exact permutation p-values
check_percentile(doMedian ? 50.0 : fStatisticValue, pc_mode, n_threads,&pdata);
vector<double> vPvalues;
int i = 0;
for (vector<Gene>::iterator iter = vGenes.begin(); iter != vGenes.end(); ++iter)
{
// Copy results from pdata struture
(*iter).originalDiff = (double)pdata.pc_diff[i];
(*iter).originalMedianCases = (double)pdata.pc_cases[i];
(*iter).<API key> = (double)pdata.pc_controls[i];
(*iter).foldChange = pdata.fold_change[i];
(*iter).pValue = pdata.p_values[i];
// Add pvalue to a vector of pvalues for being correcte by FDR
vPvalues.push_back((*iter).pValue);
i++;
}
vector<double> correctedPvalues;
correct_pvalues_fdr(vPvalues, correctedPvalues);
// Print to file
std::ofstream outfile(outFile.c_str(), std::ofstream::out);
// Header File
outfile << headerOutput << endl;
vector<double>::const_iterator iterCorrected = correctedPvalues.begin();
outfile.precision(15);
for (vector<Gene>::const_iterator iter = vGenes.begin(); iter != vGenes.end();++iter)
{
outfile << (*iter).geneName << "\t" << (*iter).originalDiff << "\t" << (*iter).originalMedianCases;
outfile << "\t" << (*iter).<API key> << "\t" << (*iter).foldChange << "\t" << (*iter).pValue << "\t" << (*iterCorrected) << endl;
++iterCorrected;
}
free(pdata.grp);
free(pdata.data);
free(pdata.p_values);
outfile.close();
return 0;
}
|
// <API key>.h
// iTerm2
#import <Cocoa/Cocoa.h>
@interface <API key> : NSObject
+ (NSCharacterSet *)<API key>;
+ (NSArray<NSBezierPath *> *)<API key>:(unichar)code
cellSize:(NSSize)cellSize
scale:(CGFloat)scale;
@end
|
/* Remove some alpha blended PNGs to avoid problems with antiquated IE <= 6. It doesn't look much different unless you look closely. */
div.post-content, span.post-frame-top, span.post-frame-bottom { background-image: url(images/post-ie.png);height:1px; overflow:visible}
div.widget-center, span.widget-top, span.widget-bottom { background-image: url(images/widget-ie.png);height:1px; overflow:visible}
div.post-body img { margin: 0 5px}
div.post-footer {height: 1px; overflow: visible}
/*
Some crude fixes for ie5.5 to get it to a useable state, not going to worry about 5.5 beyond this.
*/
body.ie5 div.widget-centre, body.ie55 div.widget-centre{ width: 290px}
body.ie5 div.container, body.ie55 div.container{ margin-left: 20px;} /* As ie55 won't centre the container on the page I'll move it a small amount away from the edge. */
body.ie5 div#comments-block, body.ie55 div#comments-block{width:543px}
|
#ifndef _LINUX_PRIO_HEAP_H
#define _LINUX_PRIO_HEAP_H
#include <linux/gfp.h>
struct ptr_heap {
void **ptrs;
int max;
int size;
int (*gt)(void *, void *);
};
extern int heap_init(struct ptr_heap *heap, size_t size, gfp_t gfp_mask,
int (*gt)(void *, void *));
void heap_free(struct ptr_heap *heap);
extern void *heap_insert(struct ptr_heap *heap, void *p);
#endif
|
<?php
include_once '../libs/Connection.php';
include_once '../libs/tree_editor.php';
class tree_performance extends tree_editor{
public function __construct(){
parent::__construct();
if(!isset($_POST['action'])){
header("content-type:text/xml;charset=UTF-8");
if(isset($_GET['refresh'])){
$refresh = $_GET['refresh'];
}else{
$refresh = false;
}
echo ($this->getXml($_GET['id'],$_GET['autoload'],$refresh));
}else{
$this->db->query("START TRANSACTION");
$response = "";
$response = $this->parseRequest();
$this->db->query("COMMIT");
echo json_encode($response);
}
}
public function getXmlTree($id=0,$rf,$autoload = true){
$xml = '<tree id="'.$id.'">';
$xml .= $this-><API key>($id,$rf,$autoload);
$xml .= '</tree>';
return $xml;
}
protected function <API key>($id,$rf,$autoload){
if($autoload=='false'){
$xml = '<item child="1" text="My Studygroups" id="mystg" im1="folder_open.png" im2="folder_closed.png">';
$xml .= $this->getItemLoad(0,"mystg",$rf,false);
$xml .= '</item>';
}else{
if($id == "0"){
$xml = '<item child="1" text="My Studygroups" id="mystg" im1="folder_open.png" im2="folder_closed.png">';
}else{
$xml .= $this->getItemLoad(0,$id,$rf,true);
$xml .= '</item>';
}
}
return $xml;
}
protected function getChildItems($type){
$items = array();
switch ($type) {
case 'studygroup':
$items[] = array('table' => 'performance',
'id' => 'performance',
'pid' => 'studygroup_id',
);
break;
case 'mystg':
$items[] = array('table' => 'studygroups',
'id' => 'studygroup',
'pid' => 'mystg',
);
break;
default:
break;
}
return $items;
}
public function <API key>($type){
switch ($type) {
case 'studygroup':
$table = "studygroups";
$id_name = "studygroup";
break;
case 'mystg':
$table = "mystg";
$id_name = "mystg";
break;
case 'performance':
$table = "performance";
$id_name = "performance";
break;
default:
break;
}
return array('table' => $table, 'id_name' => $id_name);
}
public function addPerformanceItem($item){
switch($item){
case "performance":
$values = array(
'studygroup_id' => $_POST["id"],
'public' => 1
);
break;
}
$itemInfo = $this-><API key>($item);
$response = $this->addItem($itemInfo['table'],$values,$item);
return $response;
}
public function <API key>($item){
switch($item){
case "performance":
$values = array(
'studygroup_id' => $_POST["id"],
'public' => 0
);
break;
}
$itemInfo = $this-><API key>($item);
$response = $this->addItem($itemInfo['table'],$values,$item);
return $response;
}
public function <API key>($id,$item){
$itemInfo = $this-><API key>($item);
$response = $this->removeItem($id,$itemInfo['table'],$itemInfo['id_name']);
return $response;
}
public function <API key>($id,$item){
$itemInfo = $this-><API key>($item);
$response = $this->shareItem($id,$itemInfo['table'],$itemInfo['id_name']);
return $response;
}
public function <API key>($id,$item){
$itemInfo = $this-><API key>($item);
$response = $this->privateItem($id,$itemInfo['table'],$itemInfo['id_name']);
return $response;
}
public function <API key>($id,$item){
$itemInfo = $this-><API key>($item);
$response = $this->duplicateItem($id,$itemInfo['table'],$itemInfo['id_name']);
return $response;
}
public function movePerformanceItem($ids,$item,$sid,$lid,$par){
$itemInfo = $this-><API key>($item);
switch($item){
case "performance":
$parents = array(
'studygroup_id' => $_POST['studygroup']
);
break;
}
$response = $this->setParent($sid,$parents,$lid,$itemInfo['id_name'],$itemInfo['table']);
return $response;
}
public function <API key>($ids,$item,$sid,$lid,$par){
$itemInfo = $this-><API key>($item);
switch($item){
case "assignment":
$parents = array(
'studygroup_id' => $_POST['studygroup']
);
break;
}
$response = $this-><API key>($sid,$item);
$response = $this->setParent($response['id'],$parents,$lid,$itemInfo['id_name'],$itemInfo['table']);
return $response;
}
public function getPerformanceInfo($id){
$result = $this->db->query("
SELECT perf.title_en as title_p, stg.title_en as title_g
FROM performance perf
inner join studygroups stg on perf.studygroup_id=stg.studygroup_id
where perf.performance_id=$id
");
while($row = mysql_fetch_assoc($result)){
$name = $row['title_p'];
$studygroup = $row['title_g'];
}
return array(
"name" => $name,
"studygroup" => $studygroup
);
}
public function <API key>($id){
$description = "";
$notes = "";
$result = $this->db->query("SELECT content_en,owner_notes FROM performance WHERE performance_id=$id LIMIT 1");
while($row = mysql_fetch_assoc($result)){
$description = $row['content_en'];
$notes = $row['owner_notes'];
}
return array('content' => $description,'notes' => $notes);
}
public function <API key>($id,$content,$notes){
$result = $this->db->query("UPDATE performance SET content_en='$content',owner_notes='$notes' WHERE performance_id=$id");
return array('update' => true);
}
function parseRequest(){
if(isset($_POST['action'])){
$action = $_POST['action'];
$act = explode("_", $action);
$id = $_POST['id'];
$response = "";
$id = $_POST['id'];
$name = $_POST['name'];
$type = $_POST['node'];
$ids = explode(",", $_POST['ids']);
$par = explode('_', $_POST['tid']);
$sid = $_POST['sid'];
$lid = $_POST['lid'];
$content = $_POST['content'];
$notes = $_POST['notes'];
$description = $_POST['description'];
switch($act[0]){
case "new":
$response = $this->addPerformanceItem($act[1]);
break;
case "delete":
$response = $this-><API key>($id,$act[1]);
break;
case "duplicate":
$response = $this-><API key>($id,$act[1]);
break;
case "rename":
$table = $this-><API key>($type);
$response = $this->rename($id,$name,$table['table'],$table['id_name']);
break;
case "move":
$response = $this->movePerformanceItem($ids,$act[1],$sid,$lid,$par);
break;
case "movedupl":
$response = $this-><API key>($ids,$act[1],$sid,$lid,$par);
break;
case "getassignment":
$response = $this-><API key>($id);
$response["info"] = $this->getAssignmentInfo($id);
break;
case "putassignment":
$response = $this-><API key>($id,$content,$notes);
break;
case "share":
$response = $this-><API key>($id,$act[1]);
break;
case "private":
$response = $this-><API key>($id,$act[1]);
break;
case "<API key>":
$response = $this-><API key>($id);
$response["info"] = $this->getPerformanceInfo($id);
$response["info"]["view_assessments"] = dlang("<API key>","View Performance");
$response["info"]["assessment_image"] = "dhtmlx/dhtmlxTree/codebase/imgs/csh_schoolmule/performance.png";
break;
case "getperformance":
$response = $this-><API key>($id);
$response["info"] = $this->getPerformanceInfo($id);
$response["info"]["view_assessments"] = "View Assessments";
$response["info"]["assessment_image"] = "dhtmlx/dhtmlxTree/codebase/imgs/csh_schoolmule/assessment.png";
break;
case "putperformance":
$response = $this-><API key>($id,$_POST['content'],$_POST['notes']);
break;
case "newnotpublic":
$response = $this-><API key>($act[1]);
}
return $response;
}else{
return false;
}
}
}
?>
|
package <API key>;
import java.awt.image.BufferedImage;
import java.io.File;
import javax.swing.ImageIcon;
/**
*
* @author fonter
*/
public class ImageContainer {
private final BufferedImage image;
private ImageIcon cache;
private final File file;
public ImageContainer (BufferedImage image, File file) {
this.image = image;
this.file = file;
}
public String getNormalizeName () {
String name = file.getName();
int pos = name.lastIndexOf(".");
if (pos > 0) {
return name.substring(0, pos);
}
return name;
}
public ImageIcon getCache () {
return cache;
}
public File getFile () {
return file;
}
public BufferedImage getImage () {
return image;
}
public void setCache (ImageIcon cache) {
this.cache = cache;
}
public boolean isCacheCreate () {
return cache != null;
}
}
|
from buildbot.status.web.auth import IAuth
class Authz(object):
"""Decide who can do what."""
knownActions = [
# If you add a new action here, be sure to also update the documentation
# at docs/cfg-statustargets.texinfo
'gracefulShutdown',
'forceBuild',
'forceAllBuilds',
'pingBuilder',
'stopBuild',
'stopAllBuilds',
'cancelPendingBuild',
]
def __init__(self,
default_action=False,
auth=None,
**kwargs):
self.auth = auth
if auth:
assert IAuth.providedBy(auth)
self.config = dict( (a, default_action) for a in self.knownActions )
for act in self.knownActions:
if act in kwargs:
self.config[act] = kwargs[act]
del kwargs[act]
if kwargs:
raise ValueError("unknown authorization action(s) " + ", ".join(kwargs.keys()))
def advertiseAction(self, action):
"""Should the web interface even show the form for ACTION?"""
if action not in self.knownActions:
raise KeyError("unknown action")
cfg = self.config.get(action, False)
if cfg:
return True
return False
def needAuthForm(self, action):
"""Does this action require an authentication form?"""
if action not in self.knownActions:
raise KeyError("unknown action")
cfg = self.config.get(action, False)
if cfg == 'auth' or callable(cfg):
return True
return False
def actionAllowed(self, action, request, *args):
"""Is this ACTION allowed, given this http REQUEST?"""
if action not in self.knownActions:
raise KeyError("unknown action")
cfg = self.config.get(action, False)
if cfg:
if cfg == 'auth' or callable(cfg):
if not self.auth:
return False
user = request.args.get("username", ["<unknown>"])[0]
passwd = request.args.get("passwd", ["<no-password>"])[0]
if user == "<unknown>" or passwd == "<no-password>":
return False
if self.auth.authenticate(user, passwd):
if callable(cfg) and not cfg(user, *args):
return False
return True
return False
else:
return True # anyone can do this..
|
<?php
/**
* Helpers for handling timezone based event datetimes.
*
* In our timezone logic, the term "local" refers to the locality of an event
* rather than the local WordPress timezone.
*/
class <API key> {
const SITE_TIMEZONE = 'site';
const EVENT_TIMEZONE = 'event';
/**
* Container for reusable DateTimeZone objects.
*
* @var array
*/
protected static $timezones = array();
public static function init() {
self::invalidate_caches();
}
/**
* Clear any cached timezone-related values when appropriate.
*
* Currently we are concerned only with the site timezone abbreviation.
*/
protected static function invalidate_caches() {
add_filter( '<API key>', array( __CLASS__, '<API key>' ) );
add_filter( '<API key>', array( __CLASS__, '<API key>' ) );
}
/**
* Wipe the cached site timezone abbreviation, if set.
*
* @param mixed $option_val (passed through without modification)
*
* @return mixed
*/
public static function <API key>( $option_val ) {
delete_transient( '<API key>' );
return $option_val;
}
/**
* Returns the current site-wide timezone string.
*
* Based on the core WP code found in wp-admin/options-general.php.
*
* @return string
*/
public static function wp_timezone_string() {
$current_offset = get_option( 'gmt_offset' );
$tzstring = get_option( 'timezone_string' );
// Return the timezone string if already set
if ( ! empty( $tzstring ) ) {
return $tzstring;
}
// Otherwise return the UTC offset
if ( 0 == $current_offset ) {
return 'UTC+0';
} elseif ( $current_offset < 0 ) {
return 'UTC' . $current_offset;
}
return 'UTC+' . $current_offset;
}
/**
* Returns the current site-wide timezone string abbreviation, if it can be
* determined or falls back on the full timezone string/offset text.
*
* @param string $date
*
* @return string
*/
public static function wp_timezone_abbr( $date ) {
$abbr = get_transient( '<API key>' );
if ( empty( $abbr ) ) {
$timezone_string = self::wp_timezone_string();
$abbr = self::abbr( $date, $timezone_string );
set_transient( '<API key>', $abbr );
}
return empty( $abbr )
? $timezone_string
: $abbr;
}
/**
* Helper function to retrieve the timezone string for a given UTC offset
*
* This is a close copy of WooCommerce's wc_timezone_string() method
*
* @param string $offset UTC offset
*
* @return string
*/
public static function <API key>( $offset ) {
if ( ! self::is_utc_offset( $offset ) ) {
return $offset;
}
// ensure we have the minutes on the offset
if ( ! strpos( $offset, ':' ) ) {
$offset .= ':00';
}
$offset = str_replace( 'UTC', '', $offset );
list( $hours, $minutes ) = explode( ':', $offset );
$seconds = $hours * 60 * 60 + $minutes * 60;
// attempt to guess the timezone string from the UTC offset
$timezone = <API key>( '', $seconds, 0 );
if ( false === $timezone ) {
$is_dst = date( 'I' );
foreach ( <API key>() as $abbr ) {
foreach ( $abbr as $city ) {
if (
$city['dst'] == $is_dst
&& $city['offset'] == $seconds
) {
return $city['timezone_id'];
}
}
}
// fallback to UTC
return 'UTC';
}
return $timezone;
}
/**
* Tried to convert the provided $datetime to UTC from the timezone represented by $tzstring.
*
* Though the usual range of formats are allowed, $datetime ordinarily ought to be something
* like the "Y-m-d H:i:s" format (ie, no timezone information). If it itself contains timezone
* data, the results may be unexpected.
*
* In those cases where the conversion fails to take place, the $datetime string will be
* returned untouched.
*
* @param string $datetime
* @param string $tzstring
*
* @return string
*/
public static function to_utc( $datetime, $tzstring ) {
if ( self::is_utc_offset( $tzstring ) ) {
return self::apply_offset( $datetime, $tzstring, true );
}
try {
$local = self::get_timezone( $tzstring );
$utc = self::get_timezone( 'UTC' );
$datetime = date_create( $datetime, $local )->setTimezone( $utc );
return $datetime->format( <API key>::DBDATETIMEFORMAT );
}
catch ( Exception $e ) {
return $datetime;
}
}
/**
* Tries to convert the provided $datetime to the timezone represented by $tzstring.
*
* This is the sister function of self::to_utc() - please review the docs for that method
* for more information.
*
* @param string $datetime
* @param string $tzstring
*
* @return string
*/
public static function to_tz( $datetime, $tzstring ) {
if ( self::is_utc_offset( $tzstring ) ) {
return self::apply_offset( $datetime, $tzstring );
}
try {
$local = self::get_timezone( $tzstring );
$utc = self::get_timezone( 'UTC' );
$datetime = date_create( $datetime, $utc )->setTimezone( $local );
return $datetime->format( <API key>::DBDATETIMEFORMAT );
}
catch ( Exception $e ) {
return $datetime;
}
}
/**
* Tests to see if the timezone string is a UTC offset, ie "UTC+2".
*
* @param string $timezone
*
* @return bool
*/
public static function is_utc_offset( $timezone ) {
$timezone = trim( $timezone );
return ( 0 === strpos( $timezone, 'UTC' ) && strlen( $timezone ) > 3 );
}
/**
* @param string $datetime
* @param mixed $offset (string or numeric offset)
* @param bool $invert = false
*
* @return string
*/
public static function apply_offset( $datetime, $offset, $invert = false ) {
// Normalize
$offset = strtolower( trim( $offset ) );
// Strip any leading "utc" text if set
if ( 0 === strpos( $offset, 'utc' ) ) {
$offset = substr( $offset, 3 );
}
// It's possible no adjustment will be needed
if ( 0 === $offset ) {
return $datetime;
}
// Convert the offset to minutes for easier handling of fractional offsets
$offset = (int) ( $offset * 60 );
// Invert the offset? Useful for stripping an offset that has already been applied
if ( $invert ) {
$offset *= -1;
}
try {
if ( $offset > 0 ) $offset = '+' . $offset;
$offset = $offset . ' minutes';
$datetime = date_create( $datetime )->modify( $offset );
return $datetime->format( <API key>::DBDATETIMEFORMAT );
}
catch ( Exception $e ) {
return $datetime;
}
}
/**
* Accepts a unix timestamp and adjusts it so that when it is used to consitute
* a new datetime string, that string reflects the designated timezone.
*
* @param string $unix_timestamp
* @param string $tzstring
*
* @return string
*/
public static function adjust_timestamp( $unix_timestamp, $tzstring ) {
try {
$local = self::get_timezone( $tzstring );
$datetime = <API key>( 'U', $unix_timestamp )->format( <API key>::DBDATETIMEFORMAT );
return <API key>( 'Y-m-d H:i:s', $datetime, $local )->getTimestamp();
}
catch( Exception $e ) {
return $unix_timestamp;
}
}
/**
* Returns a DateTimeZone object matching the representation in $tzstring where
* possible, or else representing UTC (or, in the worst case, false).
*
* If optional parameter $with_fallback is true, which is the default, then in
* the event it cannot find/create the desired timezone it will try to return the
* UTC DateTimeZone before bailing.
*
* @param string $tzstring
* @param bool $with_fallback = true
*
* @return DateTimeZone|false
*/
public static function get_timezone( $tzstring, $with_fallback = true ) {
if ( isset( self::$timezones[ $tzstring ] ) ) {
return self::$timezones[ $tzstring ];
}
try {
self::$timezones[ $tzstring ] = new DateTimeZone( $tzstring );
return self::$timezones[ $tzstring ];
}
catch ( Exception $e ) {
if ( $with_fallback ) {
return self::get_timezone( 'UTC', true );
}
}
return false;
}
/**
* Returns a string representing the timezone/offset currently desired for
* the display of dates and times.
*
* @return string
*/
public static function mode() {
$mode = self::EVENT_TIMEZONE;
if ( 'site' === tribe_get_option( '<API key>' ) ) {
$mode = self::SITE_TIMEZONE;
}
return apply_filters( '<API key>', $mode );
}
/**
* Confirms if the current timezone mode matches the $possible_mode.
*
* @param string $possible_mode
*
* @return bool
*/
public static function is_mode( $possible_mode ) {
return $possible_mode === self::mode();
}
/**
* Attempts to provide the correct timezone abbreviation for the provided timezone string
* on the date given (and so should account for daylight saving time, etc).
*
* @param string $date
* @param string $timezone_string
*
* @return string
*/
public static function abbr( $date, $timezone_string ) {
try {
return date_create( $date, new DateTimeZone( $timezone_string ) )->format( 'T' );
}
catch ( Exception $e ) {
return '';
}
}
}
|
#ifndef KEDIT_TAGS_DIALOG_H
#define KEDIT_TAGS_DIALOG_H
#include <kdialog.h>
#include <Nepomuk2/Tag>
class KLineEdit;
class QListWidget;
class QListWidgetItem;
class QPushButton;
class QTimer;
/**
* @brief Dialog to edit a list of Nepomuk tags.
*
* It is possible for the user to add existing tags,
* create new tags or to remove tags.
*
* @see <API key>
*/
class KEditTagsDialog : public KDialog
{
Q_OBJECT
public:
KEditTagsDialog(const QList<Nepomuk2::Tag>& tags,
QWidget* parent = 0,
Qt::WFlags flags = 0);
virtual ~KEditTagsDialog();
QList<Nepomuk2::Tag> tags() const;
virtual bool eventFilter(QObject* watched, QEvent* event);
protected slots:
virtual void slotButtonClicked(int button);
private slots:
void slotTextEdited(const QString& text);
void slotItemEntered(QListWidgetItem* item);
void showDeleteButton();
void deleteTag();
private:
void loadTags();
void removeNewTagItem();
private:
QList<Nepomuk2::Tag> m_tags;
QListWidget* m_tagsList;
QListWidgetItem* m_newTagItem;
QListWidgetItem* m_autoCheckedItem;
QListWidgetItem* m_deleteCandidate;
KLineEdit* m_newTagEdit;
QPushButton* m_deleteButton;
QTimer* m_deleteButtonTimer;
};
#endif
|
using UnityEngine;
using System.Collections;
public class EndScreenController : ScreenController {
public UnityEngine.UI.Text winnerText;
public UnityEngine.UI.Text player1Text;
public UnityEngine.UI.Text player2Text;
public UnityEngine.UI.Text nextLeftPlayers;
public UnityEngine.UI.Text nextRightPlayers;
protected override void OnActivation() {
gameObject.SetActive(true);
winnerText.text = "...";
player1Text.text = "...";
player2Text.text = "...";
nextLeftPlayers.text = "...";
nextRightPlayers.text = "...";
int matchId = eventInfo.matchId;
StartCoroutine (DownloadMatchInfo (matchId));
}
protected override void OnDeactivation() {
}
protected override void <API key> (MatchInfo matchInfo) {
if (matchInfo.state != "OK") {
int matchId = eventInfo.matchId;
StartCoroutine (DownloadMatchInfo (matchId));
return;
}
Bot winner = matchInfo.GetWinner();
if (winner == null) {
winnerText.text = "Draw!";
Bot[] bots = matchInfo.bots;
player1Text.text = createText (bots[0].name, -1);
player2Text.text = createText (bots[1].name, -1);
} else {
winnerText.text = winner.name + " wins!";
Bot looser = matchInfo.GetLooser ();
player1Text.text = createText (winner.name, 3);
player2Text.text = createText (looser.name, 0);
}
int tournamentId = matchInfo.tournamentId;
StartCoroutine(<API key>(tournamentId));
}
protected override void <API key>(UpcomingMatches upcomingMatches) {
Match[] matches = upcomingMatches.matches;
nextLeftPlayers.text = "";
nextRightPlayers.text = "";
for (int i = 0; i < 3 && i < matches.Length; i++) {
Match match = matches [i];
string botNameLeft = match.bots [0];
string botNameRight = match.bots [1];
if (i > 0) {
nextLeftPlayers.text += "\n";
nextRightPlayers.text += "\n";
}
nextLeftPlayers.text += botNameLeft;
nextRightPlayers.text += botNameRight;
}
}
private string createText(string botName, int pts) {
string sign = pts >= 0 ? "+" : "";
return botName + "\n" + sign + pts + " pts";
}
}
|
package fortesting;
import java.io.IOException;
public class RunTransformTim {
/**
* Loads data into appropriate tables (assumes scheme already created)
*
* This will import the tables from my CSVs, which I have on dropbox. Let me
* (Tim) know if you need the CSVs No guarantee that it works on CSVs
* generated differently
*
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// String host = "127.0.0.1";
String host = "52.32.209.104";
// String keyspace = "new";
String keyspace = "main";
String year = "2012";
// if an error occurs during upload of first CSV, use
// GetLastRow.getLastEntry() to find its
// npi value and use that as start. This will not work in other CSVs
// unless the last npi
// added is greater than the largest npi in all previously loaded CSVs
String start = "";
TransformTim t = new TransformTim();
t.injest(host, keyspace, "CSV/MedicareA2012.csv", year, start);
t.injest(host, keyspace, "CSV/MedicareB2012.csv", year, "");
t.injest(host, keyspace, "CSV/MedicareC2012.csv", year, "");
t.injest(host, keyspace, "CSV/MedicareD2012.csv", year, "");
t.injest(host, keyspace, "CSV/MedicareEG2012.csv", year, "");
t.injest(host, keyspace, "CSV/MedicareHJ2012.csv", year, "");
t.injest(host, keyspace, "CSV/MedicareKL2012.csv", year, "");
t.injest(host, keyspace, "CSV/MedicareMN2012.csv", year, "");
t.injest(host, keyspace, "CSV/MedicareOQ2012.csv", year, "");
t.injest(host, keyspace, "CSV/MedicareR2012.csv", year, "");
t.injest(host, keyspace, "CSV/MedicareS2012.csv", year, "");
t.injest(host, keyspace, "CSV/MedicareTX2012.csv", year, "");
t.injest(host, keyspace, "CSV/MedicareYZ2012.csv", year, "");
}
}
|
#ifndef <API key>
#define <API key>
/**
* SECTION: ofobase
* @title: ofoBase
* @short_description: #ofoBase class definition.
* @include: openbook/ofo-base.h
*
* The ofoBase class is the class base for application objects.
*
* Properties:
* - ofo-base-getter:
* a #ofaIGetter instance;
* no default, will be %NULL if has not been previously set.
*/
#include "api/ofa-box.h"
#include "api/ofa-idbconnect-def.h"
#include "api/ofa-igetter-def.h"
#include "api/ofo-base-def.h"
G_BEGIN_DECLS
#define OFO_TYPE_BASE ( ofo_base_get_type())
#define OFO_BASE( object ) ( <API key>( object, OFO_TYPE_BASE, ofoBase ))
#define OFO_BASE_CLASS( klass ) ( <API key>( klass, OFO_TYPE_BASE, ofoBaseClass ))
#define OFO_IS_BASE( object ) ( <API key>( object, OFO_TYPE_BASE ))
#define OFO_IS_BASE_CLASS( klass ) ( <API key>(( klass ), OFO_TYPE_BASE ))
#define OFO_BASE_GET_CLASS( object ) ( <API key>(( object ), OFO_TYPE_BASE, ofoBaseClass ))
#if 0
typedef struct _ofoBaseProtected ofoBaseProtected;
typedef struct {
/*< public members >*/
GObject parent;
/*< protected members >*/
ofoBaseProtected *prot;
}
ofoBase;
typedef struct {
/*< public members >*/
GObjectClass parent;
}
ofoBaseClass;
#endif
/**
* ofo_base_getter:
* @C: the class radical (e.g. 'ACCOUNT')
* @V: the variable name (e.g. 'account')
* @T: the type of required data (e.g. 'amount')
* @R: the returned data if %NULL or an error occured (e.g. '0')
* @I: the identifier of the required field (e.g. 'ACC_DEB_AMOUNT')
*
* A convenience macro to get the value of an identified field from an
* #ofoBase object.
*/
#define ofo_base_getter(C,V,T,R,I) \
<API key>((V) && OFO_IS_ ## C(V),(R)); \
<API key>( !OFO_BASE(V)->prot->dispose_has_run, (R)); \
if( !ofa_box_is_set( OFO_BASE(V)->prot->fields,(I))) return(R); \
return(ofa_box_get_ ## T(OFO_BASE(V)->prot->fields,(I)))
/**
* ofo_base_setter:
* @C: the class mnemonic (e.g. 'ACCOUNT')
* @V: the variable name (e.g. 'account')
* @T: the type of required data (e.g. 'amount')
* @I: the identifier of the required field (e.g. 'ACC_DEB_AMOUNT')
* @D: the data value to be set
*
* A convenience macro to set the value of an identified field from an
* #ofoBase object.
*/
#define ofo_base_setter(C,V,T,I,D) \
g_return_if_fail((V) && OFO_IS_
g_return_if_fail( !OFO_BASE(V)->prot->dispose_has_run ); \
ofa_box_set_ ## T(OFO_BASE(V)->prot->fields,(I),(D))
/**
* Identifier unset value
*/
#define OFO_BASE_UNSET_ID -1
GType ofo_base_get_type ( void ) G_GNUC_CONST;
GList *<API key>( const ofsBoxDef *defs );
GList *<API key> ( const ofsBoxDef *defs,
const gchar *from,
GType type,
ofaIGetter *getter );
GList *ofo_base_load_rows ( const ofsBoxDef *defs,
const ofaIDBConnect *connect,
const gchar *from );
ofaIGetter *ofo_base_get_getter ( ofoBase *base );
G_END_DECLS
#endif /* <API key> */
|
package edu.cmu.cs.cimds.geogame.client.ui;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import com.google.gwt.user.client.ui.Grid;
import com.google.gwt.user.client.ui.Image;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.VerticalPanel;
import com.google.gwt.user.client.ui.Widget;
import edu.cmu.cs.cimds.geogame.client.model.dto.ItemDTO;
public class InventoryGrid extends Grid {
// public static final String MONEY_ICON_FILENAME = "coinbag.jpg";
public static final String BLANK_ICON_FILENAME = "blank.png";
private int numCells;
private VerticalPanel[] blanks;
private List<ItemDTO> inventory = new ArrayList<ItemDTO>();
private ItemImageCreator imageCreator;
private String imageWidth = null;
public InventoryGrid(int numRows, int numColumns) {
super(numRows, numColumns);
this.numCells = numRows * numColumns;
this.blanks = new VerticalPanel[this.numCells];
for(int i=0;i<numCells;i++) {
this.blanks[i] = new VerticalPanel();
this.blanks[i].add(new Image(BLANK_ICON_FILENAME));
this.setWidget(i, this.blanks[i]);
}
this.clearContent();
}
public InventoryGrid(int numRows, int numColumns, ItemImageCreator imageCreator) {
this(numRows, numColumns);
this.imageCreator = imageCreator;
}
public List<ItemDTO> getInventory() { return inventory; }
public void setInventory(List<ItemDTO> inventory) { this.inventory = inventory; }
// public void setInventory(List<ItemTypeDTO> inventory) {
// this.inventory = new ArrayList<ItemTypeDTO>();
// for(ItemTypeDTO itemType : inventory) {
// Item dummyItem = new Item();
// dummyItem.setItemType(itemType);
// this.inventory.add(dummyItem);
public ItemImageCreator getImageCreator() { return imageCreator; }
public void setImageCreator(ItemImageCreator imageCreator) { this.imageCreator = imageCreator; }
public void setImageWidth(String imageWidth) { this.imageWidth = imageWidth; }
public void setWidget(int numCell, Widget w) {
// if(numCell >= this.numCells) {
// throw new <API key>();
super.setWidget((int)Math.floor(numCell/this.numColumns), numCell%this.numColumns, w);
}
public void clearContent() {
for(int i=0;i<numCells;i++) {
this.setWidget(i, this.blanks[i]);
}
}
public void refresh() {
this.clearContent();
Collections.sort(this.inventory);
for(int i=0;i<this.inventory.size();i++) {
final ItemDTO item = this.inventory.get(i);
Image image = this.imageCreator.createImage(item);
if(this.imageWidth!=null) {
image.setWidth(this.imageWidth);
}
//Label descriptionLabel = new Label(item.getItemType().getName() + " - " + item.getItemType().getBasePrice() + "G", true);
VerticalPanel itemPanel = new VerticalPanel();
itemPanel.add(image);
//itemPanel.add(descriptionLabel);
this.setWidget(i, itemPanel);
}
}
}
|
<?php
function createArchiveUrl($file_path)
{
logWrite('[archive] createArchiveUrl called');
// check if file exists
if (!is_file($file_path))
{
logWrite('[archive] file not found : '. $file_path);
return False;
}
// parse the path
$splitted = explode('/', $file_path);
if ($splitted[1] != 'home' || $splitted[3] != 'opensimulator' or ($splitted[4] != 'iar' && $splitted[4] != 'oar'))
{
logWrite('[archive] wrong file path : '. $file_path);
return False;
}
$username = $splitted[2];
$archive_type = $splitted[4];
$expiration = time() + 300;
$url = '/archive?q='. $archive_type. '/'. $username. '/'. md5($expiration. ':'. $GLOBALS['config']['password']). '/'. $expiration. '/'. $splitted[5];
return $url;
}
function parseArchiveUrl($url)
{
logWrite('[archive] parseArchiveUrl called');
$splitted = explode('/', $url);
if ($splitted[1] != 'archive' || ($splitted[2] != 'oar' && $splitted[2] != 'iar'))
{
logWrite('[archive] wrong url : '. $url);
return Null;
}
$filename = $splitted[6];
$username = $splitted[3];
// check expiration
$expiration = $splitted[5];
$now = time();
if ($now > $expiration)
{
logWrite('[archive] url expired : '. $url);
return Null;
}
// check password
if ($splitted[4] != md5($expiration. ':'. $GLOBALS['config']['password']))
{
logWrite('[archive] wrong password');
return Null;
}
// check if file exists
$file_path = '/home/'. $username. '/opensimulator/'. $splitted[2]. '/'. $filename;
if (!is_file($file_path))
{
logWrite('[archive] file not found');
return Null;
}
return $file_path;
}
|
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
Sig="/home/dai/tmp/Assignment#3/Size/Signature/BatchProcessing.m"
Rect="/home/dai/tmp/Assignment#3/Size/Rectangle/BatchProcessing.sh"
Eva="/home/dai/tmp/Assignment#3/Size/Evaluation/BatchProcessing.m"
MatlabExe="/opt/Matlab2013/bin/matlab"
${MatlabExe} -nodesktop -nosplash -r "run ${Sig};quit"
sh ${Rect}
${MatlabExe} -nodesktop -nosplash -r "run ${Eva};quit"
|
<?php
defined('_JEXEC') or die;
/**
* Assignments: Tags
*/
class <API key>
{
function passTags(&$parent, &$params, $selection = array(), $assignment = 'all', $article = 0)
{
$is_content = in_array($parent->params->option, array('com_content', 'com_flexicontent'));
if (!$is_content)
{
return $parent->pass(0, $assignment);
}
$is_item = in_array($parent->params->view, array('', 'article', 'item'));
$is_category = in_array($parent->params->view, array('category'));
if ($is_item)
{
$prefix = 'com_content.article';
}
else if ($is_category)
{
$prefix = 'com_content.category';
}
else
{
return $parent->pass(0, $assignment);
}
// Load the tags.
$parent->q->clear()
->select($parent->db->quoteName('t.id'))
->from('#__tags AS t')
->join(
'INNER', '#<API key> AS m'
. ' ON m.tag_id = t.id'
. ' AND m.type_alias = ' . $parent->db->quote($prefix)
. ' AND m.content_item_id IN ( ' . $parent->params->id . ')'
);
$parent->db->setQuery($parent->q);
$tags = $parent->db->loadColumn();
if (empty($tags))
{
return $parent->pass(0, $assignment);
}
$pass = 0;
foreach ($tags as $tag)
{
$pass = in_array($tag, $selection);
if ($pass && $params->inc_children == 2)
{
$pass = 0;
}
else if (!$pass && $params->inc_children)
{
$parentids = self::getParentIds($parent, $tag);
$parentids = array_diff($parentids, array('1'));
foreach ($parentids as $id)
{
if (in_array($id, $selection))
{
$pass = 1;
break;
}
}
unset($parentids);
}
}
return $parent->pass($pass, $assignment);
}
function getParentIds(&$parent, $id = 0)
{
return $parent->getParentIds($id, 'tags');
}
}
|
/**
* SECTION:gstaudiosink
* @short_description: Simple base class for audio sinks
* @see_also: #GstAudioBaseSink, #GstAudioRingBuffer, #GstAudioSink.
*
* This is the most simple base class for audio sinks that only requires
* subclasses to implement a set of simple functions:
*
* <variablelist>
* <varlistentry>
* <term>open()</term>
* <listitem><para>Open the device.</para></listitem>
* </varlistentry>
* <varlistentry>
* <term>prepare()</term>
* <listitem><para>Configure the device with the specified format.</para></listitem>
* </varlistentry>
* <varlistentry>
* <term>write()</term>
* <listitem><para>Write samples to the device.</para></listitem>
* </varlistentry>
* <varlistentry>
* <term>reset()</term>
* <listitem><para>Unblock writes and flush the device.</para></listitem>
* </varlistentry>
* <varlistentry>
* <term>delay()</term>
* <listitem><para>Get the number of samples written but not yet played
* by the device.</para></listitem>
* </varlistentry>
* <varlistentry>
* <term>unprepare()</term>
* <listitem><para>Undo operations done by prepare.</para></listitem>
* </varlistentry>
* <varlistentry>
* <term>close()</term>
* <listitem><para>Close the device.</para></listitem>
* </varlistentry>
* </variablelist>
*
* All scheduling of samples and timestamps is done in this base class
* together with #GstAudioBaseSink using a default implementation of a
* #GstAudioRingBuffer that uses threads.
*/
#include <string.h>
#include <gst/audio/audio.h>
#include "gstaudiosink.h"
<API key> (<API key>);
#define GST_CAT_DEFAULT <API key>
#define <API key> \
(<API key>())
#define <API key>(obj) \
(<API key>((obj),<API key>,<API key>))
#define <API key>(klass) \
(<API key>((klass),<API key>,<API key>))
#define <API key>(obj) \
(<API key> ((obj), <API key>, <API key>))
#define <API key>(obj) \
((<API key> *)obj)
#define <API key>(obj) \
(<API key>((obj),<API key>))
#define <API key>(klass)\
(<API key>((klass),<API key>))
typedef struct <API key> <API key>;
typedef struct <API key> <API key>;
#define <API key>(buf) (&(((<API key> *)buf)->cond))
#define <API key>(buf) (g_cond_wait (<API key> (buf), GST_OBJECT_GET_LOCK (buf)))
#define <API key>(buf) (g_cond_signal (<API key> (buf)))
#define <API key>(buf)(g_cond_broadcast (<API key> (buf)))
struct <API key>
{
GstAudioRingBuffer object;
gboolean running;
gint queuedseg;
GCond cond;
};
struct <API key>
{
<API key> parent_class;
};
static void <API key> (<API key> *
klass);
static void <API key> (<API key> *
ringbuffer, <API key> * klass);
static void <API key> (GObject * object);
static void <API key> (GObject * object);
static <API key> *ring_parent_class = NULL;
static gboolean <API key> (GstAudioRingBuffer *
buf);
static gboolean <API key> (GstAudioRingBuffer *
buf);
static gboolean <API key> (GstAudioRingBuffer * buf,
<API key> * spec);
static gboolean <API key> (GstAudioRingBuffer * buf);
static gboolean <API key> (GstAudioRingBuffer * buf);
static gboolean <API key> (GstAudioRingBuffer * buf);
static gboolean <API key> (GstAudioRingBuffer * buf);
static guint <API key> (GstAudioRingBuffer * buf);
static gboolean <API key> (GstAudioRingBuffer * buf,
gboolean active);
/* ringbuffer abstract base class */
static GType
<API key> (void)
{
static GType ringbuffer_type = 0;
if (!ringbuffer_type) {
static const GTypeInfo ringbuffer_info = {
sizeof (<API key>),
NULL,
NULL,
(GClassInitFunc) <API key>,
NULL,
NULL,
sizeof (<API key>),
0,
(GInstanceInitFunc) <API key>,
NULL
};
ringbuffer_type =
<API key> (<API key>,
"<API key>", &ringbuffer_info, 0);
}
return ringbuffer_type;
}
static void
<API key> (<API key> * klass)
{
GObjectClass *gobject_class;
<API key> *gstringbuffer_class;
gobject_class = (GObjectClass *) klass;
gstringbuffer_class = (<API key> *) klass;
ring_parent_class = <API key> (klass);
gobject_class->dispose = <API key>;
gobject_class->finalize = <API key>;
gstringbuffer_class->open_device =
GST_DEBUG_FUNCPTR (<API key>);
gstringbuffer_class->close_device =
GST_DEBUG_FUNCPTR (<API key>);
gstringbuffer_class->acquire =
GST_DEBUG_FUNCPTR (<API key>);
gstringbuffer_class->release =
GST_DEBUG_FUNCPTR (<API key>);
gstringbuffer_class->start =
GST_DEBUG_FUNCPTR (<API key>);
gstringbuffer_class->pause =
GST_DEBUG_FUNCPTR (<API key>);
gstringbuffer_class->resume =
GST_DEBUG_FUNCPTR (<API key>);
gstringbuffer_class->stop =
GST_DEBUG_FUNCPTR (<API key>);
gstringbuffer_class->delay =
GST_DEBUG_FUNCPTR (<API key>);
gstringbuffer_class->activate =
GST_DEBUG_FUNCPTR (<API key>);
}
typedef gint (*WriteFunc) (GstAudioSink * sink, gpointer data, guint length);
/* this internal thread does nothing else but write samples to the audio device.
* It will write each segment in the ringbuffer and will update the play
* pointer.
* The start/stop methods control the thread.
*/
static void
<API key> (GstAudioRingBuffer * buf)
{
GstAudioSink *sink;
GstAudioSinkClass *csink;
<API key> *abuf = <API key> (buf);
WriteFunc writefunc;
GstMessage *message;
GValue val = { 0 };
sink = GST_AUDIO_SINK (GST_OBJECT_PARENT (buf));
csink = <API key> (sink);
GST_DEBUG_OBJECT (sink, "enter thread");
GST_OBJECT_LOCK (abuf);
GST_DEBUG_OBJECT (sink, "signal wait");
<API key> (buf);
GST_OBJECT_UNLOCK (abuf);
writefunc = csink->write;
if (writefunc == NULL)
goto no_function;
message = <API key> (GST_OBJECT_CAST (buf),
<API key>, GST_ELEMENT_CAST (sink));
g_value_init (&val, GST_TYPE_G_THREAD);
g_value_set_boxed (&val, sink->thread);
<API key> (message, &val);
g_value_unset (&val);
GST_DEBUG_OBJECT (sink, "posting ENTER stream status");
<API key> (GST_ELEMENT_CAST (sink), message);
while (TRUE) {
gint left, len;
guint8 *readptr;
gint readseg;
/* buffer must be started */
if (<API key> (buf, &readseg, &readptr, &len)) {
gint written;
left = len;
do {
written = writefunc (sink, readptr, left);
GST_LOG_OBJECT (sink, "transfered %d bytes of %d from segment %d",
written, left, readseg);
if (written < 0 || written > left) {
/* might not be critical, it e.g. happens when aborting playback */
GST_WARNING_OBJECT (sink,
"error writing data in %s (reason: %s), skipping segment (left: %d, written: %d)",
<API key> (writefunc),
(errno > 1 ? g_strerror (errno) : "unknown"), left, written);
break;
}
left -= written;
readptr += written;
} while (left > 0);
/* clear written samples */
<API key> (buf, readseg);
/* we wrote one segment */
<API key> (buf, 1);
} else {
GST_OBJECT_LOCK (abuf);
if (!abuf->running)
goto stop_running;
if (G_UNLIKELY (g_atomic_int_get (&buf->state) ==
<API key>)) {
GST_OBJECT_UNLOCK (abuf);
continue;
}
GST_DEBUG_OBJECT (sink, "signal wait");
<API key> (buf);
GST_DEBUG_OBJECT (sink, "wait for action");
<API key> (buf);
GST_DEBUG_OBJECT (sink, "got signal");
if (!abuf->running)
goto stop_running;
GST_DEBUG_OBJECT (sink, "continue running");
GST_OBJECT_UNLOCK (abuf);
}
}
/* Will never be reached */
<API key> ();
return;
/* ERROR */
no_function:
{
GST_DEBUG_OBJECT (sink, "no write function, exit thread");
return;
}
stop_running:
{
GST_OBJECT_UNLOCK (abuf);
GST_DEBUG_OBJECT (sink, "stop running, exit thread");
message = <API key> (GST_OBJECT_CAST (buf),
<API key>, GST_ELEMENT_CAST (sink));
g_value_init (&val, GST_TYPE_G_THREAD);
g_value_set_boxed (&val, sink->thread);
<API key> (message, &val);
g_value_unset (&val);
GST_DEBUG_OBJECT (sink, "posting LEAVE stream status");
<API key> (GST_ELEMENT_CAST (sink), message);
return;
}
}
static void
<API key> (<API key> * ringbuffer,
<API key> * g_class)
{
ringbuffer->running = FALSE;
ringbuffer->queuedseg = 0;
g_cond_init (&ringbuffer->cond);
}
static void
<API key> (GObject * object)
{
G_OBJECT_CLASS (ring_parent_class)->dispose (object);
}
static void
<API key> (GObject * object)
{
<API key> *ringbuffer = <API key> (object);
g_cond_clear (&ringbuffer->cond);
G_OBJECT_CLASS (ring_parent_class)->finalize (object);
}
static gboolean
<API key> (GstAudioRingBuffer * buf)
{
GstAudioSink *sink;
GstAudioSinkClass *csink;
gboolean result = TRUE;
sink = GST_AUDIO_SINK (GST_OBJECT_PARENT (buf));
csink = <API key> (sink);
if (csink->open)
result = csink->open (sink);
if (!result)
goto could_not_open;
return result;
could_not_open:
{
GST_DEBUG_OBJECT (sink, "could not open device");
return FALSE;
}
}
static gboolean
<API key> (GstAudioRingBuffer * buf)
{
GstAudioSink *sink;
GstAudioSinkClass *csink;
gboolean result = TRUE;
sink = GST_AUDIO_SINK (GST_OBJECT_PARENT (buf));
csink = <API key> (sink);
if (csink->close)
result = csink->close (sink);
if (!result)
goto could_not_close;
return result;
could_not_close:
{
GST_DEBUG_OBJECT (sink, "could not close device");
return FALSE;
}
}
static gboolean
<API key> (GstAudioRingBuffer * buf,
<API key> * spec)
{
GstAudioSink *sink;
GstAudioSinkClass *csink;
gboolean result = FALSE;
sink = GST_AUDIO_SINK (GST_OBJECT_PARENT (buf));
csink = <API key> (sink);
if (csink->prepare)
result = csink->prepare (sink, spec);
if (!result)
goto could_not_prepare;
/* set latency to one more segment as we need some headroom */
spec->seglatency = spec->segtotal + 1;
buf->size = spec->segtotal * spec->segsize;
buf->memory = g_malloc (buf->size);
if (buf->spec.type == <API key>) {
<API key> (buf->spec.info.finfo, buf->memory,
buf->size);
} else {
/* FIXME, non-raw formats get 0 as the empty sample */
memset (buf->memory, 0, buf->size);
}
return TRUE;
/* ERRORS */
could_not_prepare:
{
GST_DEBUG_OBJECT (sink, "could not prepare device");
return FALSE;
}
}
static gboolean
<API key> (GstAudioRingBuffer * buf, gboolean active)
{
GstAudioSink *sink;
<API key> *abuf;
GError *error = NULL;
sink = GST_AUDIO_SINK (GST_OBJECT_PARENT (buf));
abuf = <API key> (buf);
if (active) {
abuf->running = TRUE;
GST_DEBUG_OBJECT (sink, "starting thread");
sink->thread = g_thread_try_new ("<API key>",
(GThreadFunc) <API key>, buf, &error);
if (!sink->thread || error != NULL)
goto thread_failed;
GST_DEBUG_OBJECT (sink, "waiting for thread");
/* the object lock is taken */
<API key> (buf);
GST_DEBUG_OBJECT (sink, "thread is started");
} else {
abuf->running = FALSE;
GST_DEBUG_OBJECT (sink, "signal wait");
<API key> (buf);
GST_OBJECT_UNLOCK (buf);
/* join the thread */
g_thread_join (sink->thread);
GST_OBJECT_LOCK (buf);
}
return TRUE;
/* ERRORS */
thread_failed:
{
if (error)
GST_ERROR_OBJECT (sink, "could not create thread %s", error->message);
else
GST_ERROR_OBJECT (sink, "could not create thread for unknown reason");
g_clear_error (&error);
return FALSE;
}
}
/* function is called with LOCK */
static gboolean
<API key> (GstAudioRingBuffer * buf)
{
GstAudioSink *sink;
GstAudioSinkClass *csink;
gboolean result = FALSE;
sink = GST_AUDIO_SINK (GST_OBJECT_PARENT (buf));
csink = <API key> (sink);
/* free the buffer */
g_free (buf->memory);
buf->memory = NULL;
if (csink->unprepare)
result = csink->unprepare (sink);
if (!result)
goto could_not_unprepare;
GST_DEBUG_OBJECT (sink, "unprepared");
return result;
could_not_unprepare:
{
GST_DEBUG_OBJECT (sink, "could not unprepare device");
return FALSE;
}
}
static gboolean
<API key> (GstAudioRingBuffer * buf)
{
GstAudioSink *sink;
sink = GST_AUDIO_SINK (GST_OBJECT_PARENT (buf));
GST_DEBUG_OBJECT (sink, "start, sending signal");
<API key> (buf);
return TRUE;
}
static gboolean
<API key> (GstAudioRingBuffer * buf)
{
GstAudioSink *sink;
GstAudioSinkClass *csink;
sink = GST_AUDIO_SINK (GST_OBJECT_PARENT (buf));
csink = <API key> (sink);
/* unblock any pending writes to the audio device */
if (csink->reset) {
GST_DEBUG_OBJECT (sink, "reset...");
csink->reset (sink);
GST_DEBUG_OBJECT (sink, "reset done");
}
return TRUE;
}
static gboolean
<API key> (GstAudioRingBuffer * buf)
{
GstAudioSink *sink;
GstAudioSinkClass *csink;
sink = GST_AUDIO_SINK (GST_OBJECT_PARENT (buf));
csink = <API key> (sink);
/* unblock any pending writes to the audio device */
if (csink->reset) {
GST_DEBUG_OBJECT (sink, "reset...");
csink->reset (sink);
GST_DEBUG_OBJECT (sink, "reset done");
}
#if 0
if (abuf->running) {
GST_DEBUG_OBJECT (sink, "stop, waiting...");
<API key> (buf);
GST_DEBUG_OBJECT (sink, "stopped");
}
#endif
return TRUE;
}
static guint
<API key> (GstAudioRingBuffer * buf)
{
GstAudioSink *sink;
GstAudioSinkClass *csink;
guint res = 0;
sink = GST_AUDIO_SINK (GST_OBJECT_PARENT (buf));
csink = <API key> (sink);
if (csink->delay)
res = csink->delay (sink);
return res;
}
/* AudioSink signals and args */
enum
{
/* FILL ME */
LAST_SIGNAL
};
enum
{
ARG_0,
};
#define _do_init \
<API key> (<API key>, "audiosink", 0, "audiosink element");
#define <API key> parent_class
<API key> (GstAudioSink, gst_audio_sink,
<API key>, _do_init);
static GstAudioRingBuffer *<API key> (GstAudioBaseSink *
sink);
static void
<API key> (GstAudioSinkClass * klass)
{
<API key> *<API key>;
<API key> = (<API key> *) klass;
<API key>->create_ringbuffer =
GST_DEBUG_FUNCPTR (<API key>);
g_type_class_ref (<API key>);
}
static void
gst_audio_sink_init (GstAudioSink * audiosink)
{
}
static GstAudioRingBuffer *
<API key> (GstAudioBaseSink * sink)
{
GstAudioRingBuffer *buffer;
GST_DEBUG_OBJECT (sink, "creating ringbuffer");
buffer = g_object_new (<API key>, NULL);
GST_DEBUG_OBJECT (sink, "created ringbuffer @%p", buffer);
return buffer;
}
|
ul.yprList {list-style:none;padding:8px 0;margin:0;}
ul.yprList li {float:left;width:310px;padding:5px;margin:0;text-align:center;}
ul.yprList li img {display:block;border:5px solid #ccc;width:300px;height:auto;}
|
package mx.gob.sct.utic.mimappir.admseg.postgreSQL.services;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import mx.gob.sct.utic.mimappir.admseg.postgreSQL.model.SEGUSUARIO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.<API key>;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.<API key>;
import org.springframework.transaction.annotation.Transactional;
/**
* A custom service for retrieving users from a custom datasource, such as a
* database.
* <p>
* This custom service must implement Spring's {@link UserDetailsService}
*/
@Transactional(value="<API key>",readOnly=true)
public class <API key> implements UserDetailsService{
private SEGUSUARIO_Service SEGUSUARIO_Service;
//private UserDAO userDAO2 = new UserDAO();
/**
* Retrieves a user record containing the user's credentials and access.
*/
public UserDetails loadUserByUsername(String username)
throws <API key>, DataAccessException {
// Declare a null Spring User
UserDetails user = null;
try {
// Search database for a user that matches the specified username
// You can provide a custom DAO to access your persistence layer
// Or use JDBC to access your database
// DbUser is our custom domain user. This is not the same as
// Spring's User
List<SEGUSUARIO> registros = SEGUSUARIO_Service.getUsuario(username);
//List<SEGUSUARIO> registros = SEGUSUARIO_Service.getUsuariosList();
Iterator<SEGUSUARIO> it = registros.iterator();
SEGUSUARIO dbUser = null;
while(it.hasNext()){
dbUser = it.next();
}
// Populate the Spring User object with details from the dbUser
// Here we just pass the username, password, and access level
// getAuthorities() will translate the access level to the correct
// role type
user = new User(dbUser.getCUSUARIO(), dbUser.getCPASSWORD(), true, true,
true, true, getAuthorities(0));
} catch (Exception e) {
throw new <API key>("Error in retrieving user");
}
// Return user to Spring for processing.
// Take note we're not the one evaluating whether this user is
// authenticated or valid
// We just merely retrieve a user that matches the specified username
return user;
}
/**
* Retrieves the correct ROLE type depending on the access level, where
* access level is an Integer. Basically, this interprets the access value
* whether it's for a regular user or admin.
*
* @param access
* an integer value representing the access of the user
* @return collection of granted authorities
*/
public Collection<GrantedAuthority> getAuthorities(Integer access) {
// Create a list of grants for this user
List<GrantedAuthority> authList = new ArrayList<GrantedAuthority>(2);
// All users are granted with ROLE_USER access
// Therefore this user gets a ROLE_USER by default
authList.add(new <API key>("ROLE_USER"));
// Check if this user has admin access
// We interpret Integer(1) as an admin user
if (access.compareTo(1) == 0) {
// User has admin access
authList.add(new <API key>("ROLE_ADMIN"));
}
// Return list of granted authorities
return authList;
}
@Autowired
public void setMenuService(SEGUSUARIO_Service service) {
this.SEGUSUARIO_Service = service;
}
}
|
<?xml version="1.0" encoding="ascii"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"DTD/xhtml1-transitional.dtd">
<html xmlns="http:
<head>
<title>translate.storage.pypo</title>
<link rel="stylesheet" href="epydoc.css" type="text/css" />
<script type="text/javascript" src="epydoc.js"></script>
</head>
<body bgcolor="white" text="black" link="blue" vlink="#204080"
alink="#204080">
<table class="navbar" border="0" width="100%" cellpadding="0"
bgcolor="#a0c0ff" cellspacing="0">
<tr valign="middle">
<!-- Home link -->
<th> <a
href="translate-module.html">Home</a> </th>
<!-- Tree link -->
<th> <a
href="module-tree.html">Trees</a> </th>
<!-- Index link -->
<th> <a
href="identifier-index.html">Indices</a> </th>
<!-- Help link -->
<th> <a
href="help.html">Help</a> </th>
<!-- Project homepage -->
<th class="navbar" align="right" width="100%">
<table border="0" cellpadding="0" cellspacing="0">
<tr><th class="navbar" align="center"
><a class="navbar" target="_top" href="http://translate.sourceforge.net/wiki/toolkit/index">Translate Toolkit</a></th>
</tr></table></th>
</tr>
</table>
<table width="100%" cellpadding="0" cellspacing="0">
<tr valign="top">
<td width="100%">
<span class="breadcrumbs">
<a href="translate-module.html">Package translate</a> ::
<a href="translate.storage-module.html">Package storage</a> ::
Module pypo
</span>
</td>
<td>
<table cellpadding="0" cellspacing="0">
<!-- hide/show private -->
<tr><td align="right"><span class="options">[<a href="javascript:void(0);" class="privatelink"
onclick="toggle_private();">hide private</a>]</span></td></tr>
<tr><td align="right"><span class="options"
>[<a href="frames.html" target="_top">frames</a
>] | <a href="translate.storage.pypo-module.html"
target="_top">no frames</a>]</span></td></tr>
</table>
</td>
</tr>
</table>
<h1 class="epydoc">Module pypo</h1><p class="nomargin-top"><span class="codelink"><a href="translate.storage.pypo-pysrc.html">source code</a></span></p>
<p>classes that hold units of .po files (pounit) or entire files (pofile)
gettext-style .po (or .pot) files are used in translations for KDE et al
(see kbabel)</p>
<a name="section-Classes"></a>
<table class="summary" border="1" cellpadding="3"
cellspacing="0" width="100%" bgcolor="white">
<tr bgcolor="#70b0f0" class="table-header">
<td colspan="2" class="table-header">
<table border="0" cellpadding="0" cellspacing="0" width="100%">
<tr valign="top">
<td align="left"><span class="table-header">Classes</span></td>
<td align="right" valign="top"
><span class="options">[<a href="#section-Classes"
class="privatelink" onclick="toggle_private();"
>hide private</a>]</span></td>
</tr>
</table>
</td>
</tr>
<tr>
<td width="15%" align="right" valign="top" class="summary">
<span class="summary-type"> </span>
</td><td class="summary">
<a href="translate.storage.pypo.pounit-class.html" class="summary-name">pounit</a>
</td>
</tr>
<tr>
<td width="15%" align="right" valign="top" class="summary">
<span class="summary-type"> </span>
</td><td class="summary">
<a href="translate.storage.pypo.pofile-class.html" class="summary-name">pofile</a><br />
A .po file containing various units
</td>
</tr>
</table>
<a name="section-Functions"></a>
<table class="summary" border="1" cellpadding="3"
cellspacing="0" width="100%" bgcolor="white">
<tr bgcolor="#70b0f0" class="table-header">
<td colspan="2" class="table-header">
<table border="0" cellpadding="0" cellspacing="0" width="100%">
<tr valign="top">
<td align="left"><span class="table-header">Functions</span></td>
<td align="right" valign="top"
><span class="options">[<a href="#section-Functions"
class="privatelink" onclick="toggle_private();"
>hide private</a>]</span></td>
</tr>
</table>
</td>
</tr>
<tr>
<td width="15%" align="right" valign="top" class="summary">
<span class="summary-type"> </span>
</td><td class="summary">
<table width="100%" cellpadding="0" cellspacing="0" border="0">
<tr>
<td><span class="summary-sig"><a href="translate.storage.pypo-module.html#escapeforpo" class="summary-sig-name">escapeforpo</a>(<span class="summary-sig-arg">line</span>)</span><br />
Escapes a line for po format.</td>
<td align="right" valign="top">
<span class="codelink"><a href="translate.storage.pypo-pysrc.html#escapeforpo">source code</a></span>
</td>
</tr>
</table>
</td>
</tr>
<tr>
<td width="15%" align="right" valign="top" class="summary">
<span class="summary-type"> </span>
</td><td class="summary">
<table width="100%" cellpadding="0" cellspacing="0" border="0">
<tr>
<td><span class="summary-sig"><a name="unescapehandler"></a><span class="summary-sig-name">unescapehandler</span>(<span class="summary-sig-arg">escape</span>)</span></td>
<td align="right" valign="top">
<span class="codelink"><a href="translate.storage.pypo-pysrc.html#unescapehandler">source code</a></span>
</td>
</tr>
</table>
</td>
</tr>
<tr>
<td width="15%" align="right" valign="top" class="summary">
<span class="summary-type"> </span>
</td><td class="summary">
<table width="100%" cellpadding="0" cellspacing="0" border="0">
<tr>
<td><span class="summary-sig"><a name="wrapline"></a><span class="summary-sig-name">wrapline</span>(<span class="summary-sig-arg">line</span>)</span><br />
Wrap text for po files.</td>
<td align="right" valign="top">
<span class="codelink"><a href="translate.storage.pypo-pysrc.html#wrapline">source code</a></span>
</td>
</tr>
</table>
</td>
</tr>
<tr>
<td width="15%" align="right" valign="top" class="summary">
<span class="summary-type"> </span>
</td><td class="summary">
<table width="100%" cellpadding="0" cellspacing="0" border="0">
<tr>
<td><span class="summary-sig"><a name="quoteforpo"></a><span class="summary-sig-name">quoteforpo</span>(<span class="summary-sig-arg">text</span>)</span><br />
quotes the given text for a PO file, returning quoted and escaped
lines</td>
<td align="right" valign="top">
<span class="codelink"><a href="translate.storage.pypo-pysrc.html#quoteforpo">source code</a></span>
</td>
</tr>
</table>
</td>
</tr>
<tr>
<td width="15%" align="right" valign="top" class="summary">
<span class="summary-type"> </span>
</td><td class="summary">
<table width="100%" cellpadding="0" cellspacing="0" border="0">
<tr>
<td><span class="summary-sig"><a href="translate.storage.pypo-module.html#extractpoline" class="summary-sig-name">extractpoline</a>(<span class="summary-sig-arg">line</span>)</span><br />
Remove quote and unescape line from po file.</td>
<td align="right" valign="top">
<span class="codelink"><a href="translate.storage.pypo-pysrc.html#extractpoline">source code</a></span>
</td>
</tr>
</table>
</td>
</tr>
<tr>
<td width="15%" align="right" valign="top" class="summary">
<span class="summary-type"> </span>
</td><td class="summary">
<table width="100%" cellpadding="0" cellspacing="0" border="0">
<tr>
<td><span class="summary-sig"><a name="unquotefrompo"></a><span class="summary-sig-name">unquotefrompo</span>(<span class="summary-sig-arg">postr</span>)</span></td>
<td align="right" valign="top">
<span class="codelink"><a href="translate.storage.pypo-pysrc.html#unquotefrompo">source code</a></span>
</td>
</tr>
</table>
</td>
</tr>
<tr>
<td width="15%" align="right" valign="top" class="summary">
<span class="summary-type"> </span>
</td><td class="summary">
<table width="100%" cellpadding="0" cellspacing="0" border="0">
<tr>
<td><span class="summary-sig"><a name="is_null"></a><span class="summary-sig-name">is_null</span>(<span class="summary-sig-arg">lst</span>)</span></td>
<td align="right" valign="top">
<span class="codelink"><a href="translate.storage.pypo-pysrc.html#is_null">source code</a></span>
</td>
</tr>
</table>
</td>
</tr>
<tr>
<td width="15%" align="right" valign="top" class="summary">
<span class="summary-type"> </span>
</td><td class="summary">
<table width="100%" cellpadding="0" cellspacing="0" border="0">
<tr>
<td><span class="summary-sig"><a name="extractstr"></a><span class="summary-sig-name">extractstr</span>(<span class="summary-sig-arg">string</span>)</span></td>
<td align="right" valign="top">
<span class="codelink"><a href="translate.storage.pypo-pysrc.html#extractstr">source code</a></span>
</td>
</tr>
</table>
</td>
</tr>
</table>
<a name="section-Variables"></a>
<table class="summary" border="1" cellpadding="3"
cellspacing="0" width="100%" bgcolor="white">
<tr bgcolor="#70b0f0" class="table-header">
<td colspan="2" class="table-header">
<table border="0" cellpadding="0" cellspacing="0" width="100%">
<tr valign="top">
<td align="left"><span class="table-header">Variables</span></td>
<td align="right" valign="top"
><span class="options">[<a href="#section-Variables"
class="privatelink" onclick="toggle_private();"
>hide private</a>]</span></td>
</tr>
</table>
</td>
</tr>
<tr>
<td width="15%" align="right" valign="top" class="summary">
<span class="summary-type"> </span>
</td><td class="summary">
<a name="lsep"></a><span class="summary-name">lsep</span> = <code title=""\n#: "">"\n#: "</code><br />
Seperator for #: entries
</td>
</tr>
<tr>
<td width="15%" align="right" valign="top" class="summary">
<span class="summary-type"> </span>
</td><td class="summary">
<a href="translate.storage.pypo-module.html#po_unescape_map" class="summary-name">po_unescape_map</a> = <code title="{"\\r": "\r", "\\t": "\t", '\\"': '"', '\\n': '\n', '\\\\': '\\'}">{"\\r": "\r", "\\t": "\t", '\\"': '"', '\\n'<code class="variable-ellipsis">...</code></code>
</td>
</tr>
<tr>
<td width="15%" align="right" valign="top" class="summary">
<span class="summary-type"> </span>
</td><td class="summary">
<a href="translate.storage.pypo-module.html#po_escape_map" class="summary-name">po_escape_map</a> = <code title="dict([(value, key) for(key, value) in po_unescape_map.items()])">dict([(value, key) for(key, value) in po_unesc<code class="variable-ellipsis">...</code></code>
</td>
</tr>
</table>
<p class="<API key>"><b>Imports:</b>
<span title="copy">copy</span>,
<span title="cStringIO">cStringIO</span>,
<span title="re">re</span>,
<span title="translate.lang.data">data</span>,
<a href="translate.misc.multistring.multistring-class.html" title="translate.misc.multistring.multistring">multistring</a>,
<a href="translate.misc.quote-module.html" title="translate.misc.quote">quote</a>,
<a href="translate.misc.textwrap-module.html" title="translate.misc.textwrap">textwrap</a>,
<a href="translate.storage.pocommon-module.html" title="translate.storage.pocommon">pocommon</a>,
<a href="translate.storage.base-module.html" title="translate.storage.base">base</a>,
<a href="translate.storage.poparser-module.html" title="translate.storage.poparser">poparser</a>,
<a href="translate.storage.pocommon-module.html#encodingToUse" title="translate.storage.pocommon.encodingToUse">encodingToUse</a>
</p><br />
<a name="<API key>"></a>
<table class="details" border="1" cellpadding="3"
cellspacing="0" width="100%" bgcolor="white">
<tr bgcolor="#70b0f0" class="table-header">
<td colspan="2" class="table-header">
<table border="0" cellpadding="0" cellspacing="0" width="100%">
<tr valign="top">
<td align="left"><span class="table-header">Function Details</span></td>
<td align="right" valign="top"
><span class="options">[<a href="#<API key>"
class="privatelink" onclick="toggle_private();"
>hide private</a>]</span></td>
</tr>
</table>
</td>
</tr>
</table>
<a name="escapeforpo"></a>
<div>
<table class="details" border="1" cellpadding="3"
cellspacing="0" width="100%" bgcolor="white">
<tr><td>
<table width="100%" cellpadding="0" cellspacing="0" border="0">
<tr valign="top"><td>
<h3 class="epydoc"><span class="sig"><span class="sig-name">escapeforpo</span>(<span class="sig-arg">line</span>)</span>
</h3>
</td><td align="right" valign="top"
><span class="codelink"><a href="translate.storage.pypo-pysrc.html#escapeforpo">source code</a></span>
</td>
</tr></table>
<p>Escapes a line for po format. assumes no occurs in the line.</p>
<dl class="fields">
<dt>Parameters:</dt>
<dd><ul class="nomargin-top">
<li><strong class="pname"><code>line</code></strong> - unescaped text</li>
</ul></dd>
</dl>
</td></tr></table>
</div>
<a name="extractpoline"></a>
<div>
<table class="details" border="1" cellpadding="3"
cellspacing="0" width="100%" bgcolor="white">
<tr><td>
<table width="100%" cellpadding="0" cellspacing="0" border="0">
<tr valign="top"><td>
<h3 class="epydoc"><span class="sig"><span class="sig-name">extractpoline</span>(<span class="sig-arg">line</span>)</span>
</h3>
</td><td align="right" valign="top"
><span class="codelink"><a href="translate.storage.pypo-pysrc.html#extractpoline">source code</a></span>
</td>
</tr></table>
<p>Remove quote and unescape line from po file.</p>
<dl class="fields">
<dt>Parameters:</dt>
<dd><ul class="nomargin-top">
<li><strong class="pname"><code>line</code></strong> - a quoted line from a po file (msgid or msgstr)</li>
</ul></dd>
</dl>
</td></tr></table>
</div>
<br />
<a name="<API key>"></a>
<table class="details" border="1" cellpadding="3"
cellspacing="0" width="100%" bgcolor="white">
<tr bgcolor="#70b0f0" class="table-header">
<td colspan="2" class="table-header">
<table border="0" cellpadding="0" cellspacing="0" width="100%">
<tr valign="top">
<td align="left"><span class="table-header">Variables Details</span></td>
<td align="right" valign="top"
><span class="options">[<a href="#<API key>"
class="privatelink" onclick="toggle_private();"
>hide private</a>]</span></td>
</tr>
</table>
</td>
</tr>
</table>
<a name="po_unescape_map"></a>
<div>
<table class="details" border="1" cellpadding="3"
cellspacing="0" width="100%" bgcolor="white">
<tr><td>
<h3 class="epydoc">po_unescape_map</h3>
<dl class="fields">
</dl>
<dl class="fields">
<dt>Value:</dt>
<dd><table><tr><td><pre class="variable">
{"\\r": "\r", "\\t": "\t", '\\"': '"', '\\n': '\n', '\\\\': '\\'}
</pre></td></tr></table>
</dd>
</dl>
</td></tr></table>
</div>
<a name="po_escape_map"></a>
<div>
<table class="details" border="1" cellpadding="3"
cellspacing="0" width="100%" bgcolor="white">
<tr><td>
<h3 class="epydoc">po_escape_map</h3>
<dl class="fields">
</dl>
<dl class="fields">
<dt>Value:</dt>
<dd><table><tr><td><pre class="variable">
dict([(value, key) for(key, value) in po_unescape_map.items()])
</pre></td></tr></table>
</dd>
</dl>
</td></tr></table>
</div>
<br />
<table class="navbar" border="0" width="100%" cellpadding="0"
bgcolor="#a0c0ff" cellspacing="0">
<tr valign="middle">
<!-- Home link -->
<th> <a
href="translate-module.html">Home</a> </th>
<!-- Tree link -->
<th> <a
href="module-tree.html">Trees</a> </th>
<!-- Index link -->
<th> <a
href="identifier-index.html">Indices</a> </th>
<!-- Help link -->
<th> <a
href="help.html">Help</a> </th>
<!-- Project homepage -->
<th class="navbar" align="right" width="100%">
<table border="0" cellpadding="0" cellspacing="0">
<tr><th class="navbar" align="center"
><a class="navbar" target="_top" href="http://translate.sourceforge.net/wiki/toolkit/index">Translate Toolkit</a></th>
</tr></table></th>
</tr>
</table>
<table border="0" cellpadding="0" cellspacing="0" width="100%%">
<tr>
<td align="left" class="footer">
Generated by Epydoc 3.0.1 on Tue Apr 12 18:11:55 2011
</td>
<td align="right" class="footer">
<a target="mainFrame" href="http://epydoc.sourceforge.net"
>http://epydoc.sourceforge.net</a>
</td>
</tr>
</table>
<script type="text/javascript">
<!
// Private objects are initially displayed (because if
// javascript is turned off then we want them to be
// visible); but by default, we want to hide them. So hide
// them unless we have a cookie that says to show them.
checkCookie();
</script>
</body>
</html>
|
#ifndef <API key>
#define <API key>
namespace tbnet {
class ServerSocket : public Socket {
public:
ServerSocket();
Socket* accept();
bool listen();
private:
int _backLog; // backlog
};
}
#endif /*SERVERSOCKET_H_*/
|
<?php
/* core/themes/classy/templates/views/views-view-grid.html.twig */
class <API key> extends Twig_Template
{
public function __construct(Twig_Environment $env)
{
parent::__construct($env);
$this->parent = false;
$this->blocks = array(
);
}
protected function doDisplay(array $context, array $blocks = array())
{
$tags = array("set" => 28, "if" => 35, "for" => 56);
$filters = array();
$functions = array();
try {
$this->env->getExtension('<API key>')->checkSecurity(
array('set', 'if', 'for'),
array(),
array()
);
} catch (<API key> $e) {
$e->setSourceContext($this->getSourceContext());
if ($e instanceof <API key> && isset($tags[$e->getTagName()])) {
$e->setTemplateLine($tags[$e->getTagName()]);
} elseif ($e instanceof <API key> && isset($filters[$e->getFilterName()])) {
$e->setTemplateLine($filters[$e->getFilterName()]);
} elseif ($e instanceof <API key> && isset($functions[$e->getFunctionName()])) {
$e->setTemplateLine($functions[$e->getFunctionName()]);
}
throw $e;
}
// line 28
$context["classes"] = array(0 => "views-view-grid", 1 => $this->getAttribute( // line 30
(isset($context["options"]) ? $context["options"] : null), "alignment", array()), 2 => ("cols-" . $this->getAttribute( // line 31
(isset($context["options"]) ? $context["options"] : null), "columns", array())), 3 => "clearfix");
// line 35
if ($this->getAttribute((isset($context["options"]) ? $context["options"] : null), "row_class_default", array())) {
// line 36
echo " ";
// line 37
$context["row_classes"] = array(0 => "views-row", 1 => ((($this->getAttribute( // line 39
(isset($context["options"]) ? $context["options"] : null), "alignment", array()) == "horizontal")) ? ("clearfix") : ("")));
}
// line 43
if ($this->getAttribute((isset($context["options"]) ? $context["options"] : null), "col_class_default", array())) {
// line 44
echo " ";
// line 45
$context["col_classes"] = array(0 => "views-col", 1 => ((($this->getAttribute( // line 47
(isset($context["options"]) ? $context["options"] : null), "alignment", array()) == "vertical")) ? ("clearfix") : ("")));
}
// line 51
if ((isset($context["title"]) ? $context["title"] : null)) {
// line 52
echo " <h3>";
echo $this->env->getExtension('<API key>')-><API key>($this->env->getExtension('Drupal\Core\Template\TwigExtension')->escapeFilter($this->env, (isset($context["title"]) ? $context["title"] : null), "html", null, true));
echo "</h3>
";
}
// line 54
echo "<div";
echo $this->env->getExtension('<API key>')-><API key>($this->env->getExtension('Drupal\Core\Template\TwigExtension')->escapeFilter($this->env, $this->getAttribute((isset($context["attributes"]) ? $context["attributes"] : null), "addClass", array(0 => (isset($context["classes"]) ? $context["classes"] : null)), "method"), "html", null, true));
echo ">
";
// line 55
if (($this->getAttribute((isset($context["options"]) ? $context["options"] : null), "alignment", array()) == "horizontal")) {
// line 56
echo " ";
$context['_parent'] = $context;
$context['_seq'] = <API key>((isset($context["items"]) ? $context["items"] : null));
$context['loop'] = array(
'parent' => $context['_parent'],
'index0' => 0,
'index' => 1,
'first' => true,
);
if (is_array($context['_seq']) || (is_object($context['_seq']) && $context['_seq'] instanceof Countable)) {
$length = count($context['_seq']);
$context['loop']['revindex0'] = $length - 1;
$context['loop']['revindex'] = $length;
$context['loop']['length'] = $length;
$context['loop']['last'] = 1 === $length;
}
foreach ($context['_seq'] as $context["_key"] => $context["row"]) {
// line 57
echo " <div";
echo $this->env->getExtension('<API key>')-><API key>($this->env->getExtension('Drupal\Core\Template\TwigExtension')->escapeFilter($this->env, $this->getAttribute($this->getAttribute($context["row"], "attributes", array()), "addClass", array(0 => (isset($context["row_classes"]) ? $context["row_classes"] : null), 1 => (($this->getAttribute((isset($context["options"]) ? $context["options"] : null), "row_class_default", array())) ? (("row-" . $this->getAttribute($context["loop"], "index", array()))) : (""))), "method"), "html", null, true));
echo ">
";
// line 58
$context['_parent'] = $context;
$context['_seq'] = <API key>($this->getAttribute($context["row"], "content", array()));
$context['loop'] = array(
'parent' => $context['_parent'],
'index0' => 0,
'index' => 1,
'first' => true,
);
if (is_array($context['_seq']) || (is_object($context['_seq']) && $context['_seq'] instanceof Countable)) {
$length = count($context['_seq']);
$context['loop']['revindex0'] = $length - 1;
$context['loop']['revindex'] = $length;
$context['loop']['length'] = $length;
$context['loop']['last'] = 1 === $length;
}
foreach ($context['_seq'] as $context["_key"] => $context["column"]) {
// line 59
echo " <div";
echo $this->env->getExtension('<API key>')-><API key>($this->env->getExtension('Drupal\Core\Template\TwigExtension')->escapeFilter($this->env, $this->getAttribute($this->getAttribute($context["column"], "attributes", array()), "addClass", array(0 => (isset($context["col_classes"]) ? $context["col_classes"] : null), 1 => (($this->getAttribute((isset($context["options"]) ? $context["options"] : null), "col_class_default", array())) ? (("col-" . $this->getAttribute($context["loop"], "index", array()))) : (""))), "method"), "html", null, true));
echo ">
";
// line 60
echo $this->env->getExtension('<API key>')-><API key>($this->env->getExtension('Drupal\Core\Template\TwigExtension')->escapeFilter($this->env, $this->getAttribute($context["column"], "content", array()), "html", null, true));
echo "
</div>
";
++$context['loop']['index0'];
++$context['loop']['index'];
$context['loop']['first'] = false;
if (isset($context['loop']['length'])) {
--$context['loop']['revindex0'];
--$context['loop']['revindex'];
$context['loop']['last'] = 0 === $context['loop']['revindex0'];
}
}
$_parent = $context['_parent'];
unset($context['_seq'], $context['_iterated'], $context['_key'], $context['column'], $context['_parent'], $context['loop']);
$context = array_intersect_key($context, $_parent) + $_parent;
// line 63
echo " </div>
";
++$context['loop']['index0'];
++$context['loop']['index'];
$context['loop']['first'] = false;
if (isset($context['loop']['length'])) {
--$context['loop']['revindex0'];
--$context['loop']['revindex'];
$context['loop']['last'] = 0 === $context['loop']['revindex0'];
}
}
$_parent = $context['_parent'];
unset($context['_seq'], $context['_iterated'], $context['_key'], $context['row'], $context['_parent'], $context['loop']);
$context = array_intersect_key($context, $_parent) + $_parent;
// line 65
echo " ";
} else {
// line 66
echo " ";
$context['_parent'] = $context;
$context['_seq'] = <API key>((isset($context["items"]) ? $context["items"] : null));
$context['loop'] = array(
'parent' => $context['_parent'],
'index0' => 0,
'index' => 1,
'first' => true,
);
if (is_array($context['_seq']) || (is_object($context['_seq']) && $context['_seq'] instanceof Countable)) {
$length = count($context['_seq']);
$context['loop']['revindex0'] = $length - 1;
$context['loop']['revindex'] = $length;
$context['loop']['length'] = $length;
$context['loop']['last'] = 1 === $length;
}
foreach ($context['_seq'] as $context["_key"] => $context["column"]) {
// line 67
echo " <div";
echo $this->env->getExtension('<API key>')-><API key>($this->env->getExtension('Drupal\Core\Template\TwigExtension')->escapeFilter($this->env, $this->getAttribute($this->getAttribute($context["column"], "attributes", array()), "addClass", array(0 => (isset($context["col_classes"]) ? $context["col_classes"] : null), 1 => (($this->getAttribute((isset($context["options"]) ? $context["options"] : null), "col_class_default", array())) ? (("col-" . $this->getAttribute($context["loop"], "index", array()))) : (""))), "method"), "html", null, true));
echo ">
";
// line 68
$context['_parent'] = $context;
$context['_seq'] = <API key>($this->getAttribute($context["column"], "content", array()));
$context['loop'] = array(
'parent' => $context['_parent'],
'index0' => 0,
'index' => 1,
'first' => true,
);
if (is_array($context['_seq']) || (is_object($context['_seq']) && $context['_seq'] instanceof Countable)) {
$length = count($context['_seq']);
$context['loop']['revindex0'] = $length - 1;
$context['loop']['revindex'] = $length;
$context['loop']['length'] = $length;
$context['loop']['last'] = 1 === $length;
}
foreach ($context['_seq'] as $context["_key"] => $context["row"]) {
// line 69
echo " <div";
echo $this->env->getExtension('<API key>')-><API key>($this->env->getExtension('Drupal\Core\Template\TwigExtension')->escapeFilter($this->env, $this->getAttribute($this->getAttribute($context["row"], "attributes", array()), "addClass", array(0 => (isset($context["row_classes"]) ? $context["row_classes"] : null), 1 => (($this->getAttribute((isset($context["options"]) ? $context["options"] : null), "row_class_default", array())) ? (("row-" . $this->getAttribute($context["loop"], "index", array()))) : (""))), "method"), "html", null, true));
echo ">
";
// line 70
echo $this->env->getExtension('<API key>')-><API key>($this->env->getExtension('Drupal\Core\Template\TwigExtension')->escapeFilter($this->env, $this->getAttribute($context["row"], "content", array()), "html", null, true));
echo "
</div>
";
++$context['loop']['index0'];
++$context['loop']['index'];
$context['loop']['first'] = false;
if (isset($context['loop']['length'])) {
--$context['loop']['revindex0'];
--$context['loop']['revindex'];
$context['loop']['last'] = 0 === $context['loop']['revindex0'];
}
}
$_parent = $context['_parent'];
unset($context['_seq'], $context['_iterated'], $context['_key'], $context['row'], $context['_parent'], $context['loop']);
$context = array_intersect_key($context, $_parent) + $_parent;
// line 73
echo " </div>
";
++$context['loop']['index0'];
++$context['loop']['index'];
$context['loop']['first'] = false;
if (isset($context['loop']['length'])) {
--$context['loop']['revindex0'];
--$context['loop']['revindex'];
$context['loop']['last'] = 0 === $context['loop']['revindex0'];
}
}
$_parent = $context['_parent'];
unset($context['_seq'], $context['_iterated'], $context['_key'], $context['column'], $context['_parent'], $context['loop']);
$context = array_intersect_key($context, $_parent) + $_parent;
// line 75
echo " ";
}
// line 76
echo "</div>
";
}
public function getTemplateName()
{
return "core/themes/classy/templates/views/views-view-grid.html.twig";
}
public function isTraitable()
{
return false;
}
public function getDebugInfo()
{
return array ( 238 => 76, 235 => 75, 220 => 73, 203 => 70, 198 => 69, 181 => 68, 176 => 67, 158 => 66, 155 => 65, 140 => 63, 123 => 60, 118 => 59, 101 => 58, 96 => 57, 78 => 56, 76 => 55, 71 => 54, 65 => 52, 63 => 51, 60 => 47, 59 => 45, 57 => 44, 55 => 43, 52 => 39, 51 => 37, 49 => 36, 47 => 35, 45 => 31, 44 => 30, 43 => 28,);
}
/** @deprecated since 1.27 (to be removed in 2.0). Use getSourceContext() instead */
public function getSource()
{
@trigger_error('The '.__METHOD__.' method is deprecated since version 1.27 and will be removed in 2.0. Use getSourceContext() instead.', E_USER_DEPRECATED);
return $this->getSourceContext()->getCode();
}
public function getSourceContext()
{
return new Twig_Source("{
/**
* @file
* Theme override for views to display rows in a grid.
*
* Available variables:
* - attributes: HTML attributes for the wrapping element.
* - title: The title of this group of rows.
* - view: The view object.
* - rows: The rendered view results.
* - options: The view plugin style options.
* - row_class_default: A flag indicating whether default classes should be
* used on rows.
* - col_class_default: A flag indicating whether default classes should be
* used on columns.
* - items: A list of grid items. Each item contains a list of rows or columns.
* The order in what comes first (row or column) depends on which alignment
* type is chosen (horizontal or vertical).
* - attributes: HTML attributes for each row or column.
* - content: A list of columns or rows. Each row or column contains:
* - attributes: HTML attributes for each row or column.
* - content: The row or column contents.
*
* @see <API key>()
*/
{%
set classes = [
'views-view-grid',
options.alignment,
'cols-' ~ options.columns,
'clearfix',
]
%}
{% if options.row_class_default %}
{%
set row_classes = [
'views-row',
options.alignment == 'horizontal' ? 'clearfix',
]
%}
{% endif %}
{% if options.col_class_default %}
{%
set col_classes = [
'views-col',
options.alignment == 'vertical' ? 'clearfix',
]
%}
{% endif %}
{% if title %}
<h3>{{ title }}</h3>
{% endif %}
<div{{ attributes.addClass(classes) }}>
{% if options.alignment == 'horizontal' %}
{% for row in items %}
<div{{ row.attributes.addClass(row_classes, options.row_class_default ? 'row-' ~ loop.index) }}>
{% for column in row.content %}
<div{{ column.attributes.addClass(col_classes, options.col_class_default ? 'col-' ~ loop.index) }}>
{{ column.content }}
</div>
{% endfor %}
</div>
{% endfor %}
{% else %}
{% for column in items %}
<div{{ column.attributes.addClass(col_classes, options.col_class_default ? 'col-' ~ loop.index) }}>
{% for row in column.content %}
<div{{ row.attributes.addClass(row_classes, options.row_class_default ? 'row-' ~ loop.index) }}>
{{ row.content }}
</div>
{% endfor %}
</div>
{% endfor %}
{% endif %}
</div>
", "core/themes/classy/templates/views/views-view-grid.html.twig", "/mnt/jeet/www/local/chipc/core/themes/classy/templates/views/views-view-grid.html.twig");
}
}
|
<?php
/**
* Joocm Avatar Table Class
*
* @package Joo!CM
*/
class JTableJoocmAvatar extends JTable {
/** @var int Unique id*/
var $id = null;
/** @var string */
var $avatar_file = null;
/** @var int */
var $published = null;
/** @var int */
var $checked_out = null;
/** @var datetime */
var $checked_out_time = null;
/** @var int */
var $id_user = null;
/**
* @param database A database connector object
*/
function __construct(&$db) {
parent::__construct('#__joocm_avatars', 'id', $db);
}
}
?>
|
package org.ljc.adoptojdk.class_name;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class <API key> {
private Collection<String> packages = null;
public Collection<String> getPackages() {
Set<String> returnPackages = new HashSet<String>();
for (Package aPackage : Package.getPackages()) {
returnPackages.add(aPackage.getName());
}
return returnPackages;
}
public List<String> <API key>(String simpleName) {
if (this.packages == null) {
this.packages = getPackages();
}
List<String> fqns = new ArrayList<String>();
for (String aPackage : packages) {
try {
String fqn = aPackage + "." + simpleName;
Class.forName(fqn);
fqns.add(fqn);
} catch (Exception e) {
// Ignore
}
}
return fqns;
}
}
|
html {
font-family: sans-serif;
-<API key>: 100%;
-ms-text-size-adjust: 100%;
}
body {
margin: 0;
}
article,
aside,
details,
figcaption,
figure,
footer,
header,
hgroup,
main,
nav,
section,
summary {
display: block;
}
audio,
canvas,
progress,
video {
display: inline-block;
vertical-align: baseline;
}
audio:not([controls]) {
display: none;
height: 0;
}
[hidden],
template {
display: none;
}
a {
background: transparent;
}
a:active,
a:hover {
outline: 0;
}
abbr[title] {
border-bottom: 1px dotted;
}
b,
strong {
font-weight: bold;
}
dfn {
font-style: italic;
}
h1 {
margin: .67em 0;
font-size: 2em;
}
mark {
color: #000;
background: #ff0;
}
small {
font-size: 80%;
}
sub,
sup {
position: relative;
font-size: 75%;
line-height: 0;
vertical-align: baseline;
}
sup {
top: -.5em;
}
sub {
bottom: -.25em;
}
img {
border: 0;
}
svg:not(:root) {
overflow: hidden;
}
figure {
margin: 1em 40px;
}
hr {
height: 0;
-webkit-box-sizing: content-box;
-moz-box-sizing: content-box;
box-sizing: content-box;
}
pre {
overflow: auto;
}
code,
kbd,
pre,
samp {
font-family: monospace, monospace;
font-size: 1em;
}
button,
input,
optgroup,
select,
textarea {
margin: 0;
font: inherit;
color: inherit;
}
button {
overflow: visible;
}
button,
select {
text-transform: none;
}
button,
html input[type="button"],
input[type="reset"],
input[type="submit"] {
-webkit-appearance: button;
cursor: pointer;
}
button[disabled],
html input[disabled] {
cursor: default;
}
button::-moz-focus-inner,
input::-moz-focus-inner {
padding: 0;
border: 0;
}
input {
line-height: normal;
}
input[type="checkbox"],
input[type="radio"] {
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
padding: 0;
}
input[type="number"]::-<API key>,
input[type="number"]::-<API key> {
height: auto;
}
input[type="search"] {
-webkit-box-sizing: content-box;
-moz-box-sizing: content-box;
box-sizing: content-box;
-webkit-appearance: textfield;
}
input[type="search"]::-<API key>,
input[type="search"]::-<API key> {
-webkit-appearance: none;
}
fieldset {
padding: .35em .625em .75em;
margin: 0 2px;
border: 1px solid #c0c0c0;
}
legend {
padding: 0;
border: 0;
}
textarea {
overflow: auto;
}
optgroup {
font-weight: bold;
}
table {
border-spacing: 0;
border-collapse: collapse;
}
td,
th {
padding: 0;
}
@media print {
* {
color: #000 !important;
text-shadow: none !important;
background: transparent !important;
-webkit-box-shadow: none !important;
box-shadow: none !important;
}
a,
a:visited {
text-decoration: underline;
}
a[href]:after {
content: " (" attr(href) ")";
}
abbr[title]:after {
content: " (" attr(title) ")";
}
a[href^="javascript:"]:after,
a[href^="#"]:after {
content: "";
}
pre,
blockquote {
border: 1px solid #999;
page-break-inside: avoid;
}
thead {
display: table-header-group;
}
tr,
img {
page-break-inside: avoid;
}
img {
max-width: 100% !important;
}
p,
h2,
h3 {
orphans: 3;
widows: 3;
}
h2,
h3 {
page-break-after: avoid;
}
select {
background: #fff !important;
}
.navbar {
display: none;
}
.table td,
.table th {
background-color: #fff !important;
}
.btn > .caret,
.dropup > .btn > .caret {
border-top-color: #000 !important;
}
.label {
border: 1px solid #000;
}
.table {
border-collapse: collapse !important;
}
.table-bordered th,
.table-bordered td {
border: 1px solid #ddd !important;
}
}
@font-face {
font-family: 'Glyphicons Halflings';
src: url('../fonts/<API key>.eot');
src: url('../fonts/<API key>.eot?#iefix') format('embedded-opentype'), url('../fonts/<API key>.woff') format('woff'), url('../fonts/<API key>.ttf') format('truetype'), url('../fonts/<API key>.svg#<API key>') format('svg');
}
.glyphicon {
position: relative;
top: 1px;
display: inline-block;
font-family: 'Glyphicons Halflings';
font-style: normal;
font-weight: normal;
line-height: 1;
-<API key>: antialiased;
-<API key>: grayscale;
}
.glyphicon-asterisk:before {
content: "\2a";
}
.glyphicon-plus:before {
content: "\2b";
}
.glyphicon-euro:before {
content: "\20ac";
}
.glyphicon-minus:before {
content: "\2212";
}
.glyphicon-cloud:before {
content: "\2601";
}
.glyphicon-envelope:before {
content: "\2709";
}
.glyphicon-pencil:before {
content: "\270f";
}
.glyphicon-glass:before {
content: "\e001";
}
.glyphicon-music:before {
content: "\e002";
}
.glyphicon-search:before {
content: "\e003";
}
.glyphicon-heart:before {
content: "\e005";
}
.glyphicon-star:before {
content: "\e006";
}
.<API key>:before {
content: "\e007";
}
.glyphicon-user:before {
content: "\e008";
}
.glyphicon-film:before {
content: "\e009";
}
.glyphicon-th-large:before {
content: "\e010";
}
.glyphicon-th:before {
content: "\e011";
}
.glyphicon-th-list:before {
content: "\e012";
}
.glyphicon-ok:before {
content: "\e013";
}
.glyphicon-remove:before {
content: "\e014";
}
.glyphicon-zoom-in:before {
content: "\e015";
}
.glyphicon-zoom-out:before {
content: "\e016";
}
.glyphicon-off:before {
content: "\e017";
}
.glyphicon-signal:before {
content: "\e018";
}
.glyphicon-cog:before {
content: "\e019";
}
.glyphicon-trash:before {
content: "\e020";
}
.glyphicon-home:before {
content: "\e021";
}
.glyphicon-file:before {
content: "\e022";
}
.glyphicon-time:before {
content: "\e023";
}
.glyphicon-road:before {
content: "\e024";
}
.<API key>:before {
content: "\e025";
}
.glyphicon-download:before {
content: "\e026";
}
.glyphicon-upload:before {
content: "\e027";
}
.glyphicon-inbox:before {
content: "\e028";
}
.<API key>:before {
content: "\e029";
}
.glyphicon-repeat:before {
content: "\e030";
}
.glyphicon-refresh:before {
content: "\e031";
}
.glyphicon-list-alt:before {
content: "\e032";
}
.glyphicon-lock:before {
content: "\e033";
}
.glyphicon-flag:before {
content: "\e034";
}
.<API key>:before {
content: "\e035";
}
.<API key>:before {
content: "\e036";
}
.<API key>:before {
content: "\e037";
}
.glyphicon-volume-up:before {
content: "\e038";
}
.glyphicon-qrcode:before {
content: "\e039";
}
.glyphicon-barcode:before {
content: "\e040";
}
.glyphicon-tag:before {
content: "\e041";
}
.glyphicon-tags:before {
content: "\e042";
}
.glyphicon-book:before {
content: "\e043";
}
.glyphicon-bookmark:before {
content: "\e044";
}
.glyphicon-print:before {
content: "\e045";
}
.glyphicon-camera:before {
content: "\e046";
}
.glyphicon-font:before {
content: "\e047";
}
.glyphicon-bold:before {
content: "\e048";
}
.glyphicon-italic:before {
content: "\e049";
}
.<API key>:before {
content: "\e050";
}
.<API key>:before {
content: "\e051";
}
.<API key>:before {
content: "\e052";
}
.<API key>:before {
content: "\e053";
}
.<API key>:before {
content: "\e054";
}
.<API key>:before {
content: "\e055";
}
.glyphicon-list:before {
content: "\e056";
}
.<API key>:before {
content: "\e057";
}
.<API key>:before {
content: "\e058";
}
.<API key>:before {
content: "\e059";
}
.glyphicon-picture:before {
content: "\e060";
}
.<API key>:before {
content: "\e062";
}
.glyphicon-adjust:before {
content: "\e063";
}
.glyphicon-tint:before {
content: "\e064";
}
.glyphicon-edit:before {
content: "\e065";
}
.glyphicon-share:before {
content: "\e066";
}
.glyphicon-check:before {
content: "\e067";
}
.glyphicon-move:before {
content: "\e068";
}
.<API key>:before {
content: "\e069";
}
.<API key>:before {
content: "\e070";
}
.glyphicon-backward:before {
content: "\e071";
}
.glyphicon-play:before {
content: "\e072";
}
.glyphicon-pause:before {
content: "\e073";
}
.glyphicon-stop:before {
content: "\e074";
}
.glyphicon-forward:before {
content: "\e075";
}
.<API key>:before {
content: "\e076";
}
.<API key>:before {
content: "\e077";
}
.glyphicon-eject:before {
content: "\e078";
}
.<API key>:before {
content: "\e079";
}
.<API key>:before {
content: "\e080";
}
.glyphicon-plus-sign:before {
content: "\e081";
}
.<API key>:before {
content: "\e082";
}
.<API key>:before {
content: "\e083";
}
.glyphicon-ok-sign:before {
content: "\e084";
}
.<API key>:before {
content: "\e085";
}
.glyphicon-info-sign:before {
content: "\e086";
}
.<API key>:before {
content: "\e087";
}
.<API key>:before {
content: "\e088";
}
.glyphicon-ok-circle:before {
content: "\e089";
}
.<API key>:before {
content: "\e090";
}
.<API key>:before {
content: "\e091";
}
.<API key>:before {
content: "\e092";
}
.glyphicon-arrow-up:before {
content: "\e093";
}
.<API key>:before {
content: "\e094";
}
.glyphicon-share-alt:before {
content: "\e095";
}
.<API key>:before {
content: "\e096";
}
.<API key>:before {
content: "\e097";
}
.<API key>:before {
content: "\e101";
}
.glyphicon-gift:before {
content: "\e102";
}
.glyphicon-leaf:before {
content: "\e103";
}
.glyphicon-fire:before {
content: "\e104";
}
.glyphicon-eye-open:before {
content: "\e105";
}
.glyphicon-eye-close:before {
content: "\e106";
}
.<API key>:before {
content: "\e107";
}
.glyphicon-plane:before {
content: "\e108";
}
.glyphicon-calendar:before {
content: "\e109";
}
.glyphicon-random:before {
content: "\e110";
}
.glyphicon-comment:before {
content: "\e111";
}
.glyphicon-magnet:before {
content: "\e112";
}
.<API key>:before {
content: "\e113";
}
.<API key>:before {
content: "\e114";
}
.glyphicon-retweet:before {
content: "\e115";
}
.<API key>:before {
content: "\e116";
}
.<API key>:before {
content: "\e117";
}
.<API key>:before {
content: "\e118";
}
.<API key>:before {
content: "\e119";
}
.<API key>:before {
content: "\e120";
}
.glyphicon-hdd:before {
content: "\e121";
}
.glyphicon-bullhorn:before {
content: "\e122";
}
.glyphicon-bell:before {
content: "\e123";
}
.<API key>:before {
content: "\e124";
}
.glyphicon-thumbs-up:before {
content: "\e125";
}
.<API key>:before {
content: "\e126";
}
.<API key>:before {
content: "\e127";
}
.glyphicon-hand-left:before {
content: "\e128";
}
.glyphicon-hand-up:before {
content: "\e129";
}
.glyphicon-hand-down:before {
content: "\e130";
}
.<API key>:before {
content: "\e131";
}
.<API key>:before {
content: "\e132";
}
.<API key>:before {
content: "\e133";
}
.<API key>:before {
content: "\e134";
}
.glyphicon-globe:before {
content: "\e135";
}
.glyphicon-wrench:before {
content: "\e136";
}
.glyphicon-tasks:before {
content: "\e137";
}
.glyphicon-filter:before {
content: "\e138";
}
.glyphicon-briefcase:before {
content: "\e139";
}
.<API key>:before {
content: "\e140";
}
.glyphicon-dashboard:before {
content: "\e141";
}
.glyphicon-paperclip:before {
content: "\e142";
}
.<API key>:before {
content: "\e143";
}
.glyphicon-link:before {
content: "\e144";
}
.glyphicon-phone:before {
content: "\e145";
}
.glyphicon-pushpin:before {
content: "\e146";
}
.glyphicon-usd:before {
content: "\e148";
}
.glyphicon-gbp:before {
content: "\e149";
}
.glyphicon-sort:before {
content: "\e150";
}
.<API key>:before {
content: "\e151";
}
.<API key>:before {
content: "\e152";
}
.<API key>:before {
content: "\e153";
}
.<API key>:before {
content: "\e154";
}
.<API key>:before {
content: "\e155";
}
.<API key>:before {
content: "\e156";
}
.glyphicon-unchecked:before {
content: "\e157";
}
.glyphicon-expand:before {
content: "\e158";
}
.<API key>:before {
content: "\e159";
}
.<API key>:before {
content: "\e160";
}
.glyphicon-log-in:before {
content: "\e161";
}
.glyphicon-flash:before {
content: "\e162";
}
.glyphicon-log-out:before {
content: "\e163";
}
.<API key>:before {
content: "\e164";
}
.glyphicon-record:before {
content: "\e165";
}
.glyphicon-save:before {
content: "\e166";
}
.glyphicon-open:before {
content: "\e167";
}
.glyphicon-saved:before {
content: "\e168";
}
.glyphicon-import:before {
content: "\e169";
}
.glyphicon-export:before {
content: "\e170";
}
.glyphicon-send:before {
content: "\e171";
}
.<API key>:before {
content: "\e172";
}
.<API key>:before {
content: "\e173";
}
.<API key>:before {
content: "\e174";
}
.<API key>:before {
content: "\e175";
}
.<API key>:before {
content: "\e176";
}
.<API key>:before {
content: "\e177";
}
.glyphicon-transfer:before {
content: "\e178";
}
.glyphicon-cutlery:before {
content: "\e179";
}
.glyphicon-header:before {
content: "\e180";
}
.<API key>:before {
content: "\e181";
}
.glyphicon-earphone:before {
content: "\e182";
}
.glyphicon-phone-alt:before {
content: "\e183";
}
.glyphicon-tower:before {
content: "\e184";
}
.glyphicon-stats:before {
content: "\e185";
}
.glyphicon-sd-video:before {
content: "\e186";
}
.glyphicon-hd-video:before {
content: "\e187";
}
.glyphicon-subtitles:before {
content: "\e188";
}
.<API key>:before {
content: "\e189";
}
.<API key>:before {
content: "\e190";
}
.glyphicon-sound-5-1:before {
content: "\e191";
}
.glyphicon-sound-6-1:before {
content: "\e192";
}
.glyphicon-sound-7-1:before {
content: "\e193";
}
.<API key>:before {
content: "\e194";
}
.<API key>:before {
content: "\e195";
}
.<API key>:before {
content: "\e197";
}
.<API key>:before {
content: "\e198";
}
.<API key>:before {
content: "\e199";
}
.<API key>:before {
content: "\e200";
}
* {
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
}
*:before,
*:after {
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
}
html {
font-size: 10px;
-<API key>: rgba(0, 0, 0, 0);
}
body {
font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
font-size: 14px;
line-height: 1.42857143;
color: #333;
background-color: #fff;
}
input,
button,
select,
textarea {
font-family: inherit;
font-size: inherit;
line-height: inherit;
}
a {
color: #428bca;
text-decoration: none;
}
a:hover,
a:focus {
color: #2a6496;
text-decoration: underline;
}
a:focus {
outline: thin dotted;
outline: 5px auto -<API key>;
outline-offset: -2px;
}
figure {
margin: 0;
}
img {
vertical-align: middle;
}
.img-responsive,
.thumbnail > img,
.thumbnail a > img,
.carousel-inner > .item > img,
.carousel-inner > .item > a > img {
display: block;
width: 100% \9;
max-width: 100%;
height: auto;
}
.img-rounded {
border-radius: 6px;
}
.img-thumbnail {
display: inline-block;
width: 100% \9;
max-width: 100%;
height: auto;
padding: 4px;
line-height: 1.42857143;
background-color: #fff;
border: 1px solid #ddd;
border-radius: 4px;
-webkit-transition: all .2s ease-in-out;
-o-transition: all .2s ease-in-out;
transition: all .2s ease-in-out;
}
.img-circle {
border-radius: 50%;
}
hr {
margin-top: 20px;
margin-bottom: 20px;
border: 0;
border-top: 1px solid #eee;
}
.sr-only {
position: absolute;
width: 1px;
height: 1px;
padding: 0;
margin: -1px;
overflow: hidden;
clip: rect(0, 0, 0, 0);
border: 0;
}
.sr-only-focusable:active,
.sr-only-focusable:focus {
position: static;
width: auto;
height: auto;
margin: 0;
overflow: visible;
clip: auto;
}
h1,
h2,
h3,
h4,
h5,
h6,
.h1,
.h2,
.h3,
.h4,
.h5,
.h6 {
font-family: inherit;
font-weight: 500;
line-height: 1.1;
color: inherit;
}
h1 small,
h2 small,
h3 small,
h4 small,
h5 small,
h6 small,
.h1 small,
.h2 small,
.h3 small,
.h4 small,
.h5 small,
.h6 small,
h1 .small,
h2 .small,
h3 .small,
h4 .small,
h5 .small,
h6 .small,
.h1 .small,
.h2 .small,
.h3 .small,
.h4 .small,
.h5 .small,
.h6 .small {
font-weight: normal;
line-height: 1;
color: #777;
}
h1,
.h1,
h2,
.h2,
h3,
.h3 {
margin-top: 20px;
margin-bottom: 10px;
}
h1 small,
.h1 small,
h2 small,
.h2 small,
h3 small,
.h3 small,
h1 .small,
.h1 .small,
h2 .small,
.h2 .small,
h3 .small,
.h3 .small {
font-size: 65%;
}
h4,
.h4,
h5,
.h5,
h6,
.h6 {
margin-top: 10px;
margin-bottom: 10px;
}
h4 small,
.h4 small,
h5 small,
.h5 small,
h6 small,
.h6 small,
h4 .small,
.h4 .small,
h5 .small,
.h5 .small,
h6 .small,
.h6 .small {
font-size: 75%;
}
h1,
.h1 {
font-size: 36px;
}
h2,
.h2 {
font-size: 30px;
}
h3,
.h3 {
font-size: 24px;
}
h4,
.h4 {
font-size: 18px;
}
h5,
.h5 {
font-size: 14px;
}
h6,
.h6 {
font-size: 12px;
}
p {
margin: 0 0 10px;
}
.lead {
margin-bottom: 20px;
font-size: 16px;
font-weight: 300;
line-height: 1.4;
}
@media (min-width: 768px) {
.lead {
font-size: 21px;
}
}
small,
.small {
font-size: 85%;
}
cite {
font-style: normal;
}
mark,
.mark {
padding: .2em;
background-color: #fcf8e3;
}
.text-left {
text-align: left;
}
.text-right {
text-align: right;
}
.text-center {
text-align: center;
}
.text-justify {
text-align: justify;
}
.text-nowrap {
white-space: nowrap;
}
.text-lowercase {
text-transform: lowercase;
}
.text-uppercase {
text-transform: uppercase;
}
.text-capitalize {
text-transform: capitalize;
}
.text-muted {
color: #777;
}
.text-primary {
color: #428bca;
}
a.text-primary:hover {
color: #3071a9;
}
.text-success {
color: #3c763d;
}
a.text-success:hover {
color: #2b542c;
}
.text-info {
color: #31708f;
}
a.text-info:hover {
color: #245269;
}
.text-warning {
color: #8a6d3b;
}
a.text-warning:hover {
color: #66512c;
}
.text-danger {
color: #a94442;
}
a.text-danger:hover {
color: #843534;
}
.bg-primary {
color: #fff;
background-color: #428bca;
}
a.bg-primary:hover {
background-color: #3071a9;
}
.bg-success {
background-color: #dff0d8;
}
a.bg-success:hover {
background-color: #c1e2b3;
}
.bg-info {
background-color: #d9edf7;
}
a.bg-info:hover {
background-color: #afd9ee;
}
.bg-warning {
background-color: #fcf8e3;
}
a.bg-warning:hover {
background-color: #f7ecb5;
}
.bg-danger {
background-color: #f2dede;
}
a.bg-danger:hover {
background-color: #e4b9b9;
}
.page-header {
padding-bottom: 9px;
margin: 40px 0 20px;
border-bottom: 1px solid #eee;
}
ul,
ol {
margin-top: 0;
margin-bottom: 10px;
}
ul ul,
ol ul,
ul ol,
ol ol {
margin-bottom: 0;
}
.list-unstyled {
padding-left: 0;
list-style: none;
}
.list-inline {
padding-left: 0;
margin-left: -5px;
list-style: none;
}
.list-inline > li {
display: inline-block;
padding-right: 5px;
padding-left: 5px;
}
dl {
margin-top: 0;
margin-bottom: 20px;
}
dt,
dd {
line-height: 1.42857143;
}
dt {
font-weight: bold;
}
dd {
margin-left: 0;
}
@media (min-width: 768px) {
.dl-horizontal dt {
float: left;
width: 160px;
overflow: hidden;
clear: left;
text-align: right;
text-overflow: ellipsis;
white-space: nowrap;
}
.dl-horizontal dd {
margin-left: 180px;
}
}
abbr[title],
abbr[data-original-title] {
cursor: help;
border-bottom: 1px dotted #777;
}
.initialism {
font-size: 90%;
text-transform: uppercase;
}
blockquote {
padding: 10px 20px;
margin: 0 0 20px;
font-size: 17.5px;
border-left: 5px solid #eee;
}
blockquote p:last-child,
blockquote ul:last-child,
blockquote ol:last-child {
margin-bottom: 0;
}
blockquote footer,
blockquote small,
blockquote .small {
display: block;
font-size: 80%;
line-height: 1.42857143;
color: #777;
}
blockquote footer:before,
blockquote small:before,
blockquote .small:before {
content: '\2014 \00A0';
}
.blockquote-reverse,
blockquote.pull-right {
padding-right: 15px;
padding-left: 0;
text-align: right;
border-right: 5px solid #eee;
border-left: 0;
}
.blockquote-reverse footer:before,
blockquote.pull-right footer:before,
.blockquote-reverse small:before,
blockquote.pull-right small:before,
.blockquote-reverse .small:before,
blockquote.pull-right .small:before {
content: '';
}
.blockquote-reverse footer:after,
blockquote.pull-right footer:after,
.blockquote-reverse small:after,
blockquote.pull-right small:after,
.blockquote-reverse .small:after,
blockquote.pull-right .small:after {
content: '\00A0 \2014';
}
blockquote:before,
blockquote:after {
content: "";
}
address {
margin-bottom: 20px;
font-style: normal;
line-height: 1.42857143;
}
code,
kbd,
pre,
samp {
font-family: Menlo, Monaco, Consolas, "Courier New", monospace;
}
code {
padding: 2px 4px;
font-size: 90%;
color: #c7254e;
background-color: #f9f2f4;
border-radius: 4px;
}
kbd {
padding: 2px 4px;
font-size: 90%;
color: #fff;
background-color: #333;
border-radius: 3px;
-webkit-box-shadow: inset 0 -1px 0 rgba(0, 0, 0, .25);
box-shadow: inset 0 -1px 0 rgba(0, 0, 0, .25);
}
kbd kbd {
padding: 0;
font-size: 100%;
-webkit-box-shadow: none;
box-shadow: none;
}
pre {
display: block;
padding: 9.5px;
margin: 0 0 10px;
font-size: 13px;
line-height: 1.42857143;
color: #333;
word-break: break-all;
word-wrap: break-word;
background-color: #f5f5f5;
border: 1px solid #ccc;
border-radius: 4px;
}
pre code {
padding: 0;
font-size: inherit;
color: inherit;
white-space: pre-wrap;
background-color: transparent;
border-radius: 0;
}
.pre-scrollable {
max-height: 340px;
overflow-y: scroll;
}
.container {
padding-right: 15px;
padding-left: 15px;
margin-right: auto;
margin-left: auto;
}
@media (min-width: 768px) {
.container {
width: 750px;
}
}
@media (min-width: 992px) {
.container {
width: 970px;
}
}
@media (min-width: 1200px) {
.container {
width: 1170px;
}
}
.container-fluid {
padding-right: 6px;
padding-left: 6px;
margin-right: auto;
margin-left: auto;
}
.row {
margin-right: -6px;
margin-left: -6px;
}
.col-xs-1, .col-sm-1, .col-md-1, .col-lg-1, .col-xs-2, .col-sm-2, .col-md-2, .col-lg-2, .col-xs-3, .col-sm-3, .col-md-3, .col-lg-3, .col-xs-4, .col-sm-4, .col-md-4, .col-lg-4, .col-xs-5, .col-sm-5, .col-md-5, .col-lg-5, .col-xs-6, .col-sm-6, .col-md-6, .col-lg-6, .col-xs-7, .col-sm-7, .col-md-7, .col-lg-7, .col-xs-8, .col-sm-8, .col-md-8, .col-lg-8, .col-xs-9, .col-sm-9, .col-md-9, .col-lg-9, .col-xs-10, .col-sm-10, .col-md-10, .col-lg-10, .col-xs-11, .col-sm-11, .col-md-11, .col-lg-11, .col-xs-12, .col-sm-12, .col-md-12, .col-lg-12 {
position: relative;
min-height: 1px;
padding-right: 6px;
padding-left: 6px;
}
.col-xs-1, .col-xs-2, .col-xs-3, .col-xs-4, .col-xs-5, .col-xs-6, .col-xs-7, .col-xs-8, .col-xs-9, .col-xs-10, .col-xs-11, .col-xs-12 {
float: left;
}
.col-xs-12 {
width: 100%;
}
.col-xs-11 {
width: 91.66666667%;
}
.col-xs-10 {
width: 83.33333333%;
}
.col-xs-9 {
width: 75%;
}
.col-xs-8 {
width: 66.66666667%;
}
.col-xs-7 {
width: 58.33333333%;
}
.col-xs-6 {
width: 50%;
}
.col-xs-5 {
width: 41.66666667%;
}
.col-xs-4 {
width: 33.33333333%;
}
.col-xs-3 {
width: 25%;
}
.col-xs-2 {
width: 16.66666667%;
}
.col-xs-1 {
width: 8.33333333%;
}
.col-xs-pull-12 {
right: 100%;
}
.col-xs-pull-11 {
right: 91.66666667%;
}
.col-xs-pull-10 {
right: 83.33333333%;
}
.col-xs-pull-9 {
right: 75%;
}
.col-xs-pull-8 {
right: 66.66666667%;
}
.col-xs-pull-7 {
right: 58.33333333%;
}
.col-xs-pull-6 {
right: 50%;
}
.col-xs-pull-5 {
right: 41.66666667%;
}
.col-xs-pull-4 {
right: 33.33333333%;
}
.col-xs-pull-3 {
right: 25%;
}
.col-xs-pull-2 {
right: 16.66666667%;
}
.col-xs-pull-1 {
right: 8.33333333%;
}
.col-xs-pull-0 {
right: auto;
}
.col-xs-push-12 {
left: 100%;
}
.col-xs-push-11 {
left: 91.66666667%;
}
.col-xs-push-10 {
left: 83.33333333%;
}
.col-xs-push-9 {
left: 75%;
}
.col-xs-push-8 {
left: 66.66666667%;
}
.col-xs-push-7 {
left: 58.33333333%;
}
.col-xs-push-6 {
left: 50%;
}
.col-xs-push-5 {
left: 41.66666667%;
}
.col-xs-push-4 {
left: 33.33333333%;
}
.col-xs-push-3 {
left: 25%;
}
.col-xs-push-2 {
left: 16.66666667%;
}
.col-xs-push-1 {
left: 8.33333333%;
}
.col-xs-push-0 {
left: auto;
}
.col-xs-offset-12 {
margin-left: 100%;
}
.col-xs-offset-11 {
margin-left: 91.66666667%;
}
.col-xs-offset-10 {
margin-left: 83.33333333%;
}
.col-xs-offset-9 {
margin-left: 75%;
}
.col-xs-offset-8 {
margin-left: 66.66666667%;
}
.col-xs-offset-7 {
margin-left: 58.33333333%;
}
.col-xs-offset-6 {
margin-left: 50%;
}
.col-xs-offset-5 {
margin-left: 41.66666667%;
}
.col-xs-offset-4 {
margin-left: 33.33333333%;
}
.col-xs-offset-3 {
margin-left: 25%;
}
.col-xs-offset-2 {
margin-left: 16.66666667%;
}
.col-xs-offset-1 {
margin-left: 8.33333333%;
}
.col-xs-offset-0 {
margin-left: 0;
}
@media (min-width: 768px) {
.col-sm-1, .col-sm-2, .col-sm-3, .col-sm-4, .col-sm-5, .col-sm-6, .col-sm-7, .col-sm-8, .col-sm-9, .col-sm-10, .col-sm-11, .col-sm-12 {
float: left;
}
.col-sm-12 {
width: 100%;
}
.col-sm-11 {
width: 91.66666667%;
}
.col-sm-10 {
width: 83.33333333%;
}
.col-sm-9 {
width: 75%;
}
.col-sm-8 {
width: 66.66666667%;
}
.col-sm-7 {
width: 58.33333333%;
}
.col-sm-6 {
width: 50%;
}
.col-sm-5 {
width: 41.66666667%;
}
.col-sm-4 {
width: 33.33333333%;
}
.col-sm-3 {
width: 25%;
}
.col-sm-2 {
width: 16.66666667%;
}
.col-sm-1 {
width: 8.33333333%;
}
.col-sm-pull-12 {
right: 100%;
}
.col-sm-pull-11 {
right: 91.66666667%;
}
.col-sm-pull-10 {
right: 83.33333333%;
}
.col-sm-pull-9 {
right: 75%;
}
.col-sm-pull-8 {
right: 66.66666667%;
}
.col-sm-pull-7 {
right: 58.33333333%;
}
.col-sm-pull-6 {
right: 50%;
}
.col-sm-pull-5 {
right: 41.66666667%;
}
.col-sm-pull-4 {
right: 33.33333333%;
}
.col-sm-pull-3 {
right: 25%;
}
.col-sm-pull-2 {
right: 16.66666667%;
}
.col-sm-pull-1 {
right: 8.33333333%;
}
.col-sm-pull-0 {
right: auto;
}
.col-sm-push-12 {
left: 100%;
}
.col-sm-push-11 {
left: 91.66666667%;
}
.col-sm-push-10 {
left: 83.33333333%;
}
.col-sm-push-9 {
left: 75%;
}
.col-sm-push-8 {
left: 66.66666667%;
}
.col-sm-push-7 {
left: 58.33333333%;
}
.col-sm-push-6 {
left: 50%;
}
.col-sm-push-5 {
left: 41.66666667%;
}
.col-sm-push-4 {
left: 33.33333333%;
}
.col-sm-push-3 {
left: 25%;
}
.col-sm-push-2 {
left: 16.66666667%;
}
.col-sm-push-1 {
left: 8.33333333%;
}
.col-sm-push-0 {
left: auto;
}
.col-sm-offset-12 {
margin-left: 100%;
}
.col-sm-offset-11 {
margin-left: 91.66666667%;
}
.col-sm-offset-10 {
margin-left: 83.33333333%;
}
.col-sm-offset-9 {
margin-left: 75%;
}
.col-sm-offset-8 {
margin-left: 66.66666667%;
}
.col-sm-offset-7 {
margin-left: 58.33333333%;
}
.col-sm-offset-6 {
margin-left: 50%;
}
.col-sm-offset-5 {
margin-left: 41.66666667%;
}
.col-sm-offset-4 {
margin-left: 33.33333333%;
}
.col-sm-offset-3 {
margin-left: 25%;
}
.col-sm-offset-2 {
margin-left: 16.66666667%;
}
.col-sm-offset-1 {
margin-left: 8.33333333%;
}
.col-sm-offset-0 {
margin-left: 0;
}
}
@media (min-width: 992px) {
.col-md-1, .col-md-2, .col-md-3, .col-md-4, .col-md-5, .col-md-6, .col-md-7, .col-md-8, .col-md-9, .col-md-10, .col-md-11, .col-md-12 {
float: left;
}
.col-md-12 {
width: 100%;
}
.col-md-11 {
width: 91.66666667%;
}
.col-md-10 {
width: 83.33333333%;
}
.col-md-9 {
width: 75%;
}
.col-md-8 {
width: 66.66666667%;
}
.col-md-7 {
width: 58.33333333%;
}
.col-md-6 {
width: 50%;
}
.col-md-5 {
width: 41.66666667%;
}
.col-md-4 {
width: 33.33333333%;
}
.col-md-3 {
width: 25%;
}
.col-md-2 {
width: 16.66666667%;
}
.col-md-1 {
width: 8.33333333%;
}
.col-md-pull-12 {
right: 100%;
}
.col-md-pull-11 {
right: 91.66666667%;
}
.col-md-pull-10 {
right: 83.33333333%;
}
.col-md-pull-9 {
right: 75%;
}
.col-md-pull-8 {
right: 66.66666667%;
}
.col-md-pull-7 {
right: 58.33333333%;
}
.col-md-pull-6 {
right: 50%;
}
.col-md-pull-5 {
right: 41.66666667%;
}
.col-md-pull-4 {
right: 33.33333333%;
}
.col-md-pull-3 {
right: 25%;
}
.col-md-pull-2 {
right: 16.66666667%;
}
.col-md-pull-1 {
right: 8.33333333%;
}
.col-md-pull-0 {
right: auto;
}
.col-md-push-12 {
left: 100%;
}
.col-md-push-11 {
left: 91.66666667%;
}
.col-md-push-10 {
left: 83.33333333%;
}
.col-md-push-9 {
left: 75%;
}
.col-md-push-8 {
left: 66.66666667%;
}
.col-md-push-7 {
left: 58.33333333%;
}
.col-md-push-6 {
left: 50%;
}
.col-md-push-5 {
left: 41.66666667%;
}
.col-md-push-4 {
left: 33.33333333%;
}
.col-md-push-3 {
left: 25%;
}
.col-md-push-2 {
left: 16.66666667%;
}
.col-md-push-1 {
left: 8.33333333%;
}
.col-md-push-0 {
left: auto;
}
.col-md-offset-12 {
margin-left: 100%;
}
.col-md-offset-11 {
margin-left: 91.66666667%;
}
.col-md-offset-10 {
margin-left: 83.33333333%;
}
.col-md-offset-9 {
margin-left: 75%;
}
.col-md-offset-8 {
margin-left: 66.66666667%;
}
.col-md-offset-7 {
margin-left: 58.33333333%;
}
.col-md-offset-6 {
margin-left: 50%;
}
.col-md-offset-5 {
margin-left: 41.66666667%;
}
.col-md-offset-4 {
margin-left: 33.33333333%;
}
.col-md-offset-3 {
margin-left: 25%;
}
.col-md-offset-2 {
margin-left: 16.66666667%;
}
.col-md-offset-1 {
margin-left: 8.33333333%;
}
.col-md-offset-0 {
margin-left: 0;
}
}
@media (min-width: 1200px) {
.col-lg-1, .col-lg-2, .col-lg-3, .col-lg-4, .col-lg-5, .col-lg-6, .col-lg-7, .col-lg-8, .col-lg-9, .col-lg-10, .col-lg-11, .col-lg-12 {
float: left;
}
.col-lg-12 {
width: 100%;
}
.col-lg-11 {
width: 91.66666667%;
}
.col-lg-10 {
width: 83.33333333%;
}
.col-lg-9 {
width: 75%;
}
.col-lg-8 {
width: 66.66666667%;
}
.col-lg-7 {
width: 58.33333333%;
}
.col-lg-6 {
width: 50%;
}
.col-lg-5 {
width: 41.66666667%;
}
.col-lg-4 {
width: 33.33333333%;
}
.col-lg-3 {
width: 25%;
}
.col-lg-2 {
width: 16.66666667%;
}
.col-lg-1 {
width: 8.33333333%;
}
.col-lg-pull-12 {
right: 100%;
}
.col-lg-pull-11 {
right: 91.66666667%;
}
.col-lg-pull-10 {
right: 83.33333333%;
}
.col-lg-pull-9 {
right: 75%;
}
.col-lg-pull-8 {
right: 66.66666667%;
}
.col-lg-pull-7 {
right: 58.33333333%;
}
.col-lg-pull-6 {
right: 50%;
}
.col-lg-pull-5 {
right: 41.66666667%;
}
.col-lg-pull-4 {
right: 33.33333333%;
}
.col-lg-pull-3 {
right: 25%;
}
.col-lg-pull-2 {
right: 16.66666667%;
}
.col-lg-pull-1 {
right: 8.33333333%;
}
.col-lg-pull-0 {
right: auto;
}
.col-lg-push-12 {
left: 100%;
}
.col-lg-push-11 {
left: 91.66666667%;
}
.col-lg-push-10 {
left: 83.33333333%;
}
.col-lg-push-9 {
left: 75%;
}
.col-lg-push-8 {
left: 66.66666667%;
}
.col-lg-push-7 {
left: 58.33333333%;
}
.col-lg-push-6 {
left: 50%;
}
.col-lg-push-5 {
left: 41.66666667%;
}
.col-lg-push-4 {
left: 33.33333333%;
}
.col-lg-push-3 {
left: 25%;
}
.col-lg-push-2 {
left: 16.66666667%;
}
.col-lg-push-1 {
left: 8.33333333%;
}
.col-lg-push-0 {
left: auto;
}
.col-lg-offset-12 {
margin-left: 100%;
}
.col-lg-offset-11 {
margin-left: 91.66666667%;
}
.col-lg-offset-10 {
margin-left: 83.33333333%;
}
.col-lg-offset-9 {
margin-left: 75%;
}
.col-lg-offset-8 {
margin-left: 66.66666667%;
}
.col-lg-offset-7 {
margin-left: 58.33333333%;
}
.col-lg-offset-6 {
margin-left: 50%;
}
.col-lg-offset-5 {
margin-left: 41.66666667%;
}
.col-lg-offset-4 {
margin-left: 33.33333333%;
}
.col-lg-offset-3 {
margin-left: 25%;
}
.col-lg-offset-2 {
margin-left: 16.66666667%;
}
.col-lg-offset-1 {
margin-left: 8.33333333%;
}
.col-lg-offset-0 {
margin-left: 0;
}
}
table {
background-color: transparent;
}
th {
text-align: left;
}
.table {
width: 100%;
max-width: 100%;
margin-bottom: 20px;
}
.table > thead > tr > th,
.table > tbody > tr > th,
.table > tfoot > tr > th,
.table > thead > tr > td,
.table > tbody > tr > td,
.table > tfoot > tr > td {
padding: 8px;
line-height: 1.42857143;
vertical-align: top;
border-top: 1px solid #ddd;
}
.table > thead > tr > th {
vertical-align: bottom;
border-bottom: 2px solid #ddd;
}
.table > caption + thead > tr:first-child > th,
.table > colgroup + thead > tr:first-child > th,
.table > thead:first-child > tr:first-child > th,
.table > caption + thead > tr:first-child > td,
.table > colgroup + thead > tr:first-child > td,
.table > thead:first-child > tr:first-child > td {
border-top: 0;
}
.table > tbody + tbody {
border-top: 2px solid #ddd;
}
.table .table {
background-color: #fff;
}
.table-condensed > thead > tr > th,
.table-condensed > tbody > tr > th,
.table-condensed > tfoot > tr > th,
.table-condensed > thead > tr > td,
.table-condensed > tbody > tr > td,
.table-condensed > tfoot > tr > td {
padding: 5px;
}
.table-bordered {
border: 1px solid #ddd;
}
.table-bordered > thead > tr > th,
.table-bordered > tbody > tr > th,
.table-bordered > tfoot > tr > th,
.table-bordered > thead > tr > td,
.table-bordered > tbody > tr > td,
.table-bordered > tfoot > tr > td {
border: 1px solid #ddd;
}
.table-bordered > thead > tr > th,
.table-bordered > thead > tr > td {
border-bottom-width: 2px;
}
.table-striped > tbody > tr:nth-child(odd) > td,
.table-striped > tbody > tr:nth-child(odd) > th {
background-color: #f9f9f9;
}
.table-hover > tbody > tr:hover > td,
.table-hover > tbody > tr:hover > th {
background-color: #f5f5f5;
}
table col[class*="col-"] {
position: static;
display: table-column;
float: none;
}
table td[class*="col-"],
table th[class*="col-"] {
position: static;
display: table-cell;
float: none;
}
.table > thead > tr > td.active,
.table > tbody > tr > td.active,
.table > tfoot > tr > td.active,
.table > thead > tr > th.active,
.table > tbody > tr > th.active,
.table > tfoot > tr > th.active,
.table > thead > tr.active > td,
.table > tbody > tr.active > td,
.table > tfoot > tr.active > td,
.table > thead > tr.active > th,
.table > tbody > tr.active > th,
.table > tfoot > tr.active > th {
background-color: #f5f5f5;
}
.table-hover > tbody > tr > td.active:hover,
.table-hover > tbody > tr > th.active:hover,
.table-hover > tbody > tr.active:hover > td,
.table-hover > tbody > tr:hover > .active,
.table-hover > tbody > tr.active:hover > th {
background-color: #e8e8e8;
}
.table > thead > tr > td.success,
.table > tbody > tr > td.success,
.table > tfoot > tr > td.success,
.table > thead > tr > th.success,
.table > tbody > tr > th.success,
.table > tfoot > tr > th.success,
.table > thead > tr.success > td,
.table > tbody > tr.success > td,
.table > tfoot > tr.success > td,
.table > thead > tr.success > th,
.table > tbody > tr.success > th,
.table > tfoot > tr.success > th {
background-color: #dff0d8;
}
.table-hover > tbody > tr > td.success:hover,
.table-hover > tbody > tr > th.success:hover,
.table-hover > tbody > tr.success:hover > td,
.table-hover > tbody > tr:hover > .success,
.table-hover > tbody > tr.success:hover > th {
background-color: #d0e9c6;
}
.table > thead > tr > td.info,
.table > tbody > tr > td.info,
.table > tfoot > tr > td.info,
.table > thead > tr > th.info,
.table > tbody > tr > th.info,
.table > tfoot > tr > th.info,
.table > thead > tr.info > td,
.table > tbody > tr.info > td,
.table > tfoot > tr.info > td,
.table > thead > tr.info > th,
.table > tbody > tr.info > th,
.table > tfoot > tr.info > th {
background-color: #d9edf7;
}
.table-hover > tbody > tr > td.info:hover,
.table-hover > tbody > tr > th.info:hover,
.table-hover > tbody > tr.info:hover > td,
.table-hover > tbody > tr:hover > .info,
.table-hover > tbody > tr.info:hover > th {
background-color: #c4e3f3;
}
.table > thead > tr > td.warning,
.table > tbody > tr > td.warning,
.table > tfoot > tr > td.warning,
.table > thead > tr > th.warning,
.table > tbody > tr > th.warning,
.table > tfoot > tr > th.warning,
.table > thead > tr.warning > td,
.table > tbody > tr.warning > td,
.table > tfoot > tr.warning > td,
.table > thead > tr.warning > th,
.table > tbody > tr.warning > th,
.table > tfoot > tr.warning > th {
background-color: #fcf8e3;
}
.table-hover > tbody > tr > td.warning:hover,
.table-hover > tbody > tr > th.warning:hover,
.table-hover > tbody > tr.warning:hover > td,
.table-hover > tbody > tr:hover > .warning,
.table-hover > tbody > tr.warning:hover > th {
background-color: #faf2cc;
}
.table > thead > tr > td.danger,
.table > tbody > tr > td.danger,
.table > tfoot > tr > td.danger,
.table > thead > tr > th.danger,
.table > tbody > tr > th.danger,
.table > tfoot > tr > th.danger,
.table > thead > tr.danger > td,
.table > tbody > tr.danger > td,
.table > tfoot > tr.danger > td,
.table > thead > tr.danger > th,
.table > tbody > tr.danger > th,
.table > tfoot > tr.danger > th {
background-color: #f2dede;
}
.table-hover > tbody > tr > td.danger:hover,
.table-hover > tbody > tr > th.danger:hover,
.table-hover > tbody > tr.danger:hover > td,
.table-hover > tbody > tr:hover > .danger,
.table-hover > tbody > tr.danger:hover > th {
background-color: #ebcccc;
}
@media screen and (max-width: 767px) {
.table-responsive {
width: 100%;
margin-bottom: 15px;
overflow-x: auto;
overflow-y: hidden;
-<API key>: touch;
-ms-overflow-style: -<API key>;
border: 1px solid #ddd;
}
.table-responsive > .table {
margin-bottom: 0;
}
.table-responsive > .table > thead > tr > th,
.table-responsive > .table > tbody > tr > th,
.table-responsive > .table > tfoot > tr > th,
.table-responsive > .table > thead > tr > td,
.table-responsive > .table > tbody > tr > td,
.table-responsive > .table > tfoot > tr > td {
white-space: nowrap;
}
.table-responsive > .table-bordered {
border: 0;
}
.table-responsive > .table-bordered > thead > tr > th:first-child,
.table-responsive > .table-bordered > tbody > tr > th:first-child,
.table-responsive > .table-bordered > tfoot > tr > th:first-child,
.table-responsive > .table-bordered > thead > tr > td:first-child,
.table-responsive > .table-bordered > tbody > tr > td:first-child,
.table-responsive > .table-bordered > tfoot > tr > td:first-child {
border-left: 0;
}
.table-responsive > .table-bordered > thead > tr > th:last-child,
.table-responsive > .table-bordered > tbody > tr > th:last-child,
.table-responsive > .table-bordered > tfoot > tr > th:last-child,
.table-responsive > .table-bordered > thead > tr > td:last-child,
.table-responsive > .table-bordered > tbody > tr > td:last-child,
.table-responsive > .table-bordered > tfoot > tr > td:last-child {
border-right: 0;
}
.table-responsive > .table-bordered > tbody > tr:last-child > th,
.table-responsive > .table-bordered > tfoot > tr:last-child > th,
.table-responsive > .table-bordered > tbody > tr:last-child > td,
.table-responsive > .table-bordered > tfoot > tr:last-child > td {
border-bottom: 0;
}
}
fieldset {
min-width: 0;
padding: 0;
margin: 0;
border: 0;
}
legend {
display: block;
width: 100%;
padding: 0;
margin-bottom: 20px;
font-size: 21px;
line-height: inherit;
color: #333;
border: 0;
border-bottom: 1px solid #e5e5e5;
}
label {
display: inline-block;
max-width: 100%;
margin-bottom: 5px;
font-weight: bold;
}
input[type="search"] {
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
}
input[type="radio"],
input[type="checkbox"] {
margin: 4px 0 0;
margin-top: 1px \9;
line-height: normal;
}
input[type="file"] {
display: block;
}
input[type="range"] {
display: block;
width: 100%;
}
select[multiple],
select[size] {
height: auto;
}
input[type="file"]:focus,
input[type="radio"]:focus,
input[type="checkbox"]:focus {
outline: thin dotted;
outline: 5px auto -<API key>;
outline-offset: -2px;
}
output {
display: block;
padding-top: 7px;
font-size: 14px;
line-height: 1.42857143;
color: #555;
}
.form-control {
display: block;
width: 100%;
height: 34px;
padding: 6px 12px;
font-size: 14px;
line-height: 1.42857143;
color: #555;
background-color: #fff;
background-image: none;
border: 1px solid #ccc;
border-radius: 4px;
-webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, .075);
box-shadow: inset 0 1px 1px rgba(0, 0, 0, .075);
-webkit-transition: border-color ease-in-out .15s, -webkit-box-shadow ease-in-out .15s;
-o-transition: border-color ease-in-out .15s, box-shadow ease-in-out .15s;
transition: border-color ease-in-out .15s, box-shadow ease-in-out .15s;
}
.form-control:focus {
border-color: #66afe9;
outline: 0;
-webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.075), 0 0 8px rgba(102, 175, 233, .6);
box-shadow: inset 0 1px 1px rgba(0,0,0,.075), 0 0 8px rgba(102, 175, 233, .6);
}
.form-control::-moz-placeholder {
color: #777;
opacity: 1;
}
.form-control:-<API key> {
color: #777;
}
.form-control::-<API key> {
color: #777;
}
.form-control[disabled],
.form-control[readonly],
fieldset[disabled] .form-control {
cursor: not-allowed;
background-color: #eee;
opacity: 1;
}
textarea.form-control {
height: auto;
}
input[type="search"] {
-webkit-appearance: none;
}
input[type="date"],
input[type="time"],
input[type="datetime-local"],
input[type="month"] {
line-height: 34px;
line-height: 1.42857143 \0;
}
input[type="date"].input-sm,
input[type="time"].input-sm,
input[type="datetime-local"].input-sm,
input[type="month"].input-sm {
line-height: 30px;
}
input[type="date"].input-lg,
input[type="time"].input-lg,
input[type="datetime-local"].input-lg,
input[type="month"].input-lg {
line-height: 46px;
}
.form-group {
margin-bottom: 15px;
}
.radio,
.checkbox {
position: relative;
display: block;
min-height: 20px;
margin-top: 10px;
margin-bottom: 10px;
}
.radio label,
.checkbox label {
padding-left: 20px;
margin-bottom: 0;
font-weight: normal;
cursor: pointer;
}
.radio input[type="radio"],
.radio-inline input[type="radio"],
.checkbox input[type="checkbox"],
.checkbox-inline input[type="checkbox"] {
position: absolute;
margin-top: 4px \9;
margin-left: -20px;
}
.radio + .radio,
.checkbox + .checkbox {
margin-top: -5px;
}
.radio-inline,
.checkbox-inline {
display: inline-block;
padding-left: 20px;
margin-bottom: 0;
font-weight: normal;
vertical-align: middle;
cursor: pointer;
}
.radio-inline + .radio-inline,
.checkbox-inline + .checkbox-inline {
margin-top: 0;
margin-left: 10px;
}
input[type="radio"][disabled],
input[type="checkbox"][disabled],
input[type="radio"].disabled,
input[type="checkbox"].disabled,
fieldset[disabled] input[type="radio"],
fieldset[disabled] input[type="checkbox"] {
cursor: not-allowed;
}
.radio-inline.disabled,
.checkbox-inline.disabled,
fieldset[disabled] .radio-inline,
fieldset[disabled] .checkbox-inline {
cursor: not-allowed;
}
.radio.disabled label,
.checkbox.disabled label,
fieldset[disabled] .radio label,
fieldset[disabled] .checkbox label {
cursor: not-allowed;
}
.form-control-static {
padding-top: 7px;
padding-bottom: 7px;
margin-bottom: 0;
}
.form-control-static.input-lg,
.form-control-static.input-sm {
padding-right: 0;
padding-left: 0;
}
.input-sm,
.form-horizontal .form-group-sm .form-control {
height: 30px;
padding: 5px 10px;
font-size: 12px;
line-height: 1.5;
border-radius: 3px;
}
select.input-sm {
height: 30px;
line-height: 30px;
}
textarea.input-sm,
select[multiple].input-sm {
height: auto;
}
.input-lg,
.form-horizontal .form-group-lg .form-control {
height: 46px;
padding: 10px 16px;
font-size: 18px;
line-height: 1.33;
border-radius: 6px;
}
select.input-lg {
height: 46px;
line-height: 46px;
}
textarea.input-lg,
select[multiple].input-lg {
height: auto;
}
.has-feedback {
position: relative;
}
.has-feedback .form-control {
padding-right: 42.5px;
}
.<API key> {
position: absolute;
top: 25px;
right: 0;
z-index: 2;
display: block;
width: 34px;
height: 34px;
line-height: 34px;
text-align: center;
}
.input-lg + .<API key> {
width: 46px;
height: 46px;
line-height: 46px;
}
.input-sm + .<API key> {
width: 30px;
height: 30px;
line-height: 30px;
}
.has-success .help-block,
.has-success .control-label,
.has-success .radio,
.has-success .checkbox,
.has-success .radio-inline,
.has-success .checkbox-inline {
color: #3c763d;
}
.has-success .form-control {
border-color: #3c763d;
-webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, .075);
box-shadow: inset 0 1px 1px rgba(0, 0, 0, .075);
}
.has-success .form-control:focus {
border-color: #2b542c;
-webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, .075), 0 0 6px #67b168;
box-shadow: inset 0 1px 1px rgba(0, 0, 0, .075), 0 0 6px #67b168;
}
.has-success .input-group-addon {
color: #3c763d;
background-color: #dff0d8;
border-color: #3c763d;
}
.has-success .<API key> {
color: #3c763d;
}
.has-warning .help-block,
.has-warning .control-label,
.has-warning .radio,
.has-warning .checkbox,
.has-warning .radio-inline,
.has-warning .checkbox-inline {
color: #8a6d3b;
}
.has-warning .form-control {
border-color: #8a6d3b;
-webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, .075);
box-shadow: inset 0 1px 1px rgba(0, 0, 0, .075);
}
.has-warning .form-control:focus {
border-color: #66512c;
-webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, .075), 0 0 6px #c0a16b;
box-shadow: inset 0 1px 1px rgba(0, 0, 0, .075), 0 0 6px #c0a16b;
}
.has-warning .input-group-addon {
color: #8a6d3b;
background-color: #fcf8e3;
border-color: #8a6d3b;
}
.has-warning .<API key> {
color: #8a6d3b;
}
.has-error .help-block,
.has-error .control-label,
.has-error .radio,
.has-error .checkbox,
.has-error .radio-inline,
.has-error .checkbox-inline {
color: #a94442;
}
.has-error .form-control {
border-color: #a94442;
-webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, .075);
box-shadow: inset 0 1px 1px rgba(0, 0, 0, .075);
}
.has-error .form-control:focus {
border-color: #843534;
-webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, .075), 0 0 6px #ce8483;
box-shadow: inset 0 1px 1px rgba(0, 0, 0, .075), 0 0 6px #ce8483;
}
.has-error .input-group-addon {
color: #a94442;
background-color: #f2dede;
border-color: #a94442;
}
.has-error .<API key> {
color: #a94442;
}
.has-feedback label.sr-only ~ .<API key> {
top: 0;
}
.help-block {
display: block;
margin-top: 5px;
margin-bottom: 10px;
color: #737373;
}
@media (min-width: 768px) {
.form-inline .form-group {
display: inline-block;
margin-bottom: 0;
vertical-align: middle;
}
.form-inline .form-control {
display: inline-block;
width: auto;
vertical-align: middle;
}
.form-inline .input-group {
display: inline-table;
vertical-align: middle;
}
.form-inline .input-group .input-group-addon,
.form-inline .input-group .input-group-btn,
.form-inline .input-group .form-control {
width: auto;
}
.form-inline .input-group > .form-control {
width: 100%;
}
.form-inline .control-label {
margin-bottom: 0;
vertical-align: middle;
}
.form-inline .radio,
.form-inline .checkbox {
display: inline-block;
margin-top: 0;
margin-bottom: 0;
vertical-align: middle;
}
.form-inline .radio label,
.form-inline .checkbox label {
padding-left: 0;
}
.form-inline .radio input[type="radio"],
.form-inline .checkbox input[type="checkbox"] {
position: relative;
margin-left: 0;
}
.form-inline .has-feedback .<API key> {
top: 0;
}
}
.form-horizontal .radio,
.form-horizontal .checkbox,
.form-horizontal .radio-inline,
.form-horizontal .checkbox-inline {
padding-top: 7px;
margin-top: 0;
margin-bottom: 0;
}
.form-horizontal .radio,
.form-horizontal .checkbox {
min-height: 27px;
}
.form-horizontal .form-group {
margin-right: -15px;
margin-left: -15px;
}
@media (min-width: 768px) {
.form-horizontal .control-label {
padding-top: 7px;
margin-bottom: 0;
text-align: right;
}
}
.form-horizontal .has-feedback .<API key> {
top: 0;
right: 15px;
}
@media (min-width: 768px) {
.form-horizontal .form-group-lg .control-label {
padding-top: 14.3px;
}
}
@media (min-width: 768px) {
.form-horizontal .form-group-sm .control-label {
padding-top: 6px;
}
}
.btn {
display: inline-block;
padding: 6px 12px;
margin-bottom: 0;
font-size: 14px;
font-weight: normal;
line-height: 1.42857143;
text-align: center;
white-space: nowrap;
vertical-align: middle;
cursor: pointer;
-webkit-user-select: none;
-moz-user-select: none;
-ms-user-select: none;
user-select: none;
background-image: none;
border: 1px solid transparent;
border-radius: 4px;
}
.btn:focus,
.btn:active:focus,
.btn.active:focus {
outline: thin dotted;
outline: 5px auto -<API key>;
outline-offset: -2px;
}
.btn:hover,
.btn:focus {
color: #333;
text-decoration: none;
}
.btn:active,
.btn.active {
background-image: none;
outline: 0;
-webkit-box-shadow: inset 0 3px 5px rgba(0, 0, 0, .125);
box-shadow: inset 0 3px 5px rgba(0, 0, 0, .125);
}
.btn.disabled,
.btn[disabled],
fieldset[disabled] .btn {
pointer-events: none;
cursor: not-allowed;
filter: alpha(opacity=65);
-webkit-box-shadow: none;
box-shadow: none;
opacity: .65;
}
.btn-default {
color: #333;
background-color: #fff;
border-color: #ccc;
}
.btn-default:hover,
.btn-default:focus,
.btn-default:active,
.btn-default.active,
.open > .dropdown-toggle.btn-default {
color: #333;
background-color: #e6e6e6;
border-color: #adadad;
}
.btn-default:active,
.btn-default.active,
.open > .dropdown-toggle.btn-default {
background-image: none;
}
.btn-default.disabled,
.btn-default[disabled],
fieldset[disabled] .btn-default,
.btn-default.disabled:hover,
.btn-default[disabled]:hover,
fieldset[disabled] .btn-default:hover,
.btn-default.disabled:focus,
.btn-default[disabled]:focus,
fieldset[disabled] .btn-default:focus,
.btn-default.disabled:active,
.btn-default[disabled]:active,
fieldset[disabled] .btn-default:active,
.btn-default.disabled.active,
.btn-default[disabled].active,
fieldset[disabled] .btn-default.active {
background-color: #fff;
border-color: #ccc;
}
.btn-default .badge {
color: #fff;
background-color: #333;
}
.btn-primary {
color: #fff;
background-color: #428bca;
border-color: #357ebd;
}
.btn-primary:hover,
.btn-primary:focus,
.btn-primary:active,
.btn-primary.active,
.open > .dropdown-toggle.btn-primary {
color: #fff;
background-color: #3071a9;
border-color: #285e8e;
}
.btn-primary:active,
.btn-primary.active,
.open > .dropdown-toggle.btn-primary {
background-image: none;
}
.btn-primary.disabled,
.btn-primary[disabled],
fieldset[disabled] .btn-primary,
.btn-primary.disabled:hover,
.btn-primary[disabled]:hover,
fieldset[disabled] .btn-primary:hover,
.btn-primary.disabled:focus,
.btn-primary[disabled]:focus,
fieldset[disabled] .btn-primary:focus,
.btn-primary.disabled:active,
.btn-primary[disabled]:active,
fieldset[disabled] .btn-primary:active,
.btn-primary.disabled.active,
.btn-primary[disabled].active,
fieldset[disabled] .btn-primary.active {
background-color: #428bca;
border-color: #357ebd;
}
.btn-primary .badge {
color: #428bca;
background-color: #fff;
}
.btn-success {
color: #fff;
background-color: #5cb85c;
border-color: #4cae4c;
}
.btn-success:hover,
.btn-success:focus,
.btn-success:active,
.btn-success.active,
.open > .dropdown-toggle.btn-success {
color: #fff;
background-color: #449d44;
border-color: #398439;
}
.btn-success:active,
.btn-success.active,
.open > .dropdown-toggle.btn-success {
background-image: none;
}
.btn-success.disabled,
.btn-success[disabled],
fieldset[disabled] .btn-success,
.btn-success.disabled:hover,
.btn-success[disabled]:hover,
fieldset[disabled] .btn-success:hover,
.btn-success.disabled:focus,
.btn-success[disabled]:focus,
fieldset[disabled] .btn-success:focus,
.btn-success.disabled:active,
.btn-success[disabled]:active,
fieldset[disabled] .btn-success:active,
.btn-success.disabled.active,
.btn-success[disabled].active,
fieldset[disabled] .btn-success.active {
background-color: #5cb85c;
border-color: #4cae4c;
}
.btn-success .badge {
color: #5cb85c;
background-color: #fff;
}
.btn-info {
color: #fff;
background-color: #5bc0de;
border-color: #46b8da;
}
.btn-info:hover,
.btn-info:focus,
.btn-info:active,
.btn-info.active,
.open > .dropdown-toggle.btn-info {
color: #fff;
background-color: #31b0d5;
border-color: #269abc;
}
.btn-info:active,
.btn-info.active,
.open > .dropdown-toggle.btn-info {
background-image: none;
}
.btn-info.disabled,
.btn-info[disabled],
fieldset[disabled] .btn-info,
.btn-info.disabled:hover,
.btn-info[disabled]:hover,
fieldset[disabled] .btn-info:hover,
.btn-info.disabled:focus,
.btn-info[disabled]:focus,
fieldset[disabled] .btn-info:focus,
.btn-info.disabled:active,
.btn-info[disabled]:active,
fieldset[disabled] .btn-info:active,
.btn-info.disabled.active,
.btn-info[disabled].active,
fieldset[disabled] .btn-info.active {
background-color: #5bc0de;
border-color: #46b8da;
}
.btn-info .badge {
color: #5bc0de;
background-color: #fff;
}
.btn-warning {
color: #fff;
background-color: #f0ad4e;
border-color: #eea236;
}
.btn-warning:hover,
.btn-warning:focus,
.btn-warning:active,
.btn-warning.active,
.open > .dropdown-toggle.btn-warning {
color: #fff;
background-color: #ec971f;
border-color: #d58512;
}
.btn-warning:active,
.btn-warning.active,
.open > .dropdown-toggle.btn-warning {
background-image: none;
}
.btn-warning.disabled,
.btn-warning[disabled],
fieldset[disabled] .btn-warning,
.btn-warning.disabled:hover,
.btn-warning[disabled]:hover,
fieldset[disabled] .btn-warning:hover,
.btn-warning.disabled:focus,
.btn-warning[disabled]:focus,
fieldset[disabled] .btn-warning:focus,
.btn-warning.disabled:active,
.btn-warning[disabled]:active,
fieldset[disabled] .btn-warning:active,
.btn-warning.disabled.active,
.btn-warning[disabled].active,
fieldset[disabled] .btn-warning.active {
background-color: #f0ad4e;
border-color: #eea236;
}
.btn-warning .badge {
color: #f0ad4e;
background-color: #fff;
}
.btn-danger {
color: #fff;
background-color: #d9534f;
border-color: #d43f3a;
}
.btn-danger:hover,
.btn-danger:focus,
.btn-danger:active,
.btn-danger.active,
.open > .dropdown-toggle.btn-danger {
color: #fff;
background-color: #c9302c;
border-color: #ac2925;
}
.btn-danger:active,
.btn-danger.active,
.open > .dropdown-toggle.btn-danger {
background-image: none;
}
.btn-danger.disabled,
.btn-danger[disabled],
fieldset[disabled] .btn-danger,
.btn-danger.disabled:hover,
.btn-danger[disabled]:hover,
fieldset[disabled] .btn-danger:hover,
.btn-danger.disabled:focus,
.btn-danger[disabled]:focus,
fieldset[disabled] .btn-danger:focus,
.btn-danger.disabled:active,
.btn-danger[disabled]:active,
fieldset[disabled] .btn-danger:active,
.btn-danger.disabled.active,
.btn-danger[disabled].active,
fieldset[disabled] .btn-danger.active {
background-color: #d9534f;
border-color: #d43f3a;
}
.btn-danger .badge {
color: #d9534f;
background-color: #fff;
}
.btn-link {
font-weight: normal;
color: #428bca;
cursor: pointer;
border-radius: 0;
}
.btn-link,
.btn-link:active,
.btn-link[disabled],
fieldset[disabled] .btn-link {
background-color: transparent;
-webkit-box-shadow: none;
box-shadow: none;
}
.btn-link,
.btn-link:hover,
.btn-link:focus,
.btn-link:active {
border-color: transparent;
}
.btn-link:hover,
.btn-link:focus {
color: #2a6496;
text-decoration: underline;
background-color: transparent;
}
.btn-link[disabled]:hover,
fieldset[disabled] .btn-link:hover,
.btn-link[disabled]:focus,
fieldset[disabled] .btn-link:focus {
color: #777;
text-decoration: none;
}
.btn-lg,
.btn-group-lg > .btn {
padding: 10px 16px;
font-size: 18px;
line-height: 1.33;
border-radius: 6px;
}
.btn-sm,
.btn-group-sm > .btn {
padding: 5px 10px;
font-size: 12px;
line-height: 1.5;
border-radius: 3px;
}
.btn-xs,
.btn-group-xs > .btn {
padding: 1px 5px;
font-size: 12px;
line-height: 1.5;
border-radius: 3px;
}
.btn-block {
display: block;
width: 100%;
}
.btn-block + .btn-block {
margin-top: 5px;
}
input[type="submit"].btn-block,
input[type="reset"].btn-block,
input[type="button"].btn-block {
width: 100%;
}
.fade {
opacity: 0;
-webkit-transition: opacity .15s linear;
-o-transition: opacity .15s linear;
transition: opacity .15s linear;
}
.fade.in {
opacity: 1;
}
.collapse {
display: none;
}
.collapse.in {
display: block;
}
tr.collapse.in {
display: table-row;
}
tbody.collapse.in {
display: table-row-group;
}
.collapsing {
position: relative;
height: 0;
overflow: hidden;
-webkit-transition: height .35s ease;
-o-transition: height .35s ease;
transition: height .35s ease;
}
.caret {
display: inline-block;
width: 0;
height: 0;
margin-left: 2px;
vertical-align: middle;
border-top: 4px solid;
border-right: 4px solid transparent;
border-left: 4px solid transparent;
}
.dropdown {
position: relative;
}
.dropdown-toggle:focus {
outline: 0;
}
.dropdown-menu {
position: absolute;
top: 100%;
left: 0;
z-index: 1000;
display: none;
float: left;
min-width: 160px;
padding: 5px 0;
margin: 2px 0 0;
font-size: 14px;
text-align: left;
list-style: none;
background-color: #fff;
-<API key>: padding-box;
background-clip: padding-box;
border: 1px solid #ccc;
border: 1px solid rgba(0, 0, 0, .15);
border-radius: 4px;
-webkit-box-shadow: 0 6px 12px rgba(0, 0, 0, .175);
box-shadow: 0 6px 12px rgba(0, 0, 0, .175);
}
.dropdown-menu.pull-right {
right: 0;
left: auto;
}
.dropdown-menu .divider {
height: 1px;
margin: 9px 0;
overflow: hidden;
background-color: #e5e5e5;
}
.dropdown-menu > li > a {
display: block;
padding: 3px 20px;
clear: both;
font-weight: normal;
line-height: 1.42857143;
color: #333;
white-space: nowrap;
}
.dropdown-menu > li > a:hover,
.dropdown-menu > li > a:focus {
color: #262626;
text-decoration: none;
background-color: #f5f5f5;
}
.dropdown-menu > .active > a,
.dropdown-menu > .active > a:hover,
.dropdown-menu > .active > a:focus {
color: #fff;
text-decoration: none;
background-color: #428bca;
outline: 0;
}
.dropdown-menu > .disabled > a,
.dropdown-menu > .disabled > a:hover,
.dropdown-menu > .disabled > a:focus {
color: #777;
}
.dropdown-menu > .disabled > a:hover,
.dropdown-menu > .disabled > a:focus {
text-decoration: none;
cursor: not-allowed;
background-color: transparent;
background-image: none;
filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
}
.open > .dropdown-menu {
display: block;
}
.open > a {
outline: 0;
}
.dropdown-menu-right {
right: 0;
left: auto;
}
.dropdown-menu-left {
right: auto;
left: 0;
}
.dropdown-header {
display: block;
padding: 3px 20px;
font-size: 12px;
line-height: 1.42857143;
color: #777;
white-space: nowrap;
}
.dropdown-backdrop {
position: fixed;
top: 0;
right: 0;
bottom: 0;
left: 0;
z-index: 990;
}
.pull-right > .dropdown-menu {
right: 0;
left: auto;
}
.dropup .caret,
.navbar-fixed-bottom .dropdown .caret {
content: "";
border-top: 0;
border-bottom: 4px solid;
}
.dropup .dropdown-menu,
.navbar-fixed-bottom .dropdown .dropdown-menu {
top: auto;
bottom: 100%;
margin-bottom: 1px;
}
@media (min-width: 768px) {
.navbar-right .dropdown-menu {
right: 0;
left: auto;
}
.navbar-right .dropdown-menu-left {
right: auto;
left: 0;
}
}
.btn-group,
.btn-group-vertical {
position: relative;
display: inline-block;
vertical-align: middle;
}
.btn-group > .btn,
.btn-group-vertical > .btn {
position: relative;
float: left;
}
.btn-group > .btn:hover,
.btn-group-vertical > .btn:hover,
.btn-group > .btn:focus,
.btn-group-vertical > .btn:focus,
.btn-group > .btn:active,
.btn-group-vertical > .btn:active,
.btn-group > .btn.active,
.btn-group-vertical > .btn.active {
z-index: 2;
}
.btn-group > .btn:focus,
.btn-group-vertical > .btn:focus {
outline: 0;
}
.btn-group .btn + .btn,
.btn-group .btn + .btn-group,
.btn-group .btn-group + .btn,
.btn-group .btn-group + .btn-group {
margin-left: -1px;
}
.btn-toolbar {
margin-left: -5px;
}
.btn-toolbar .btn-group,
.btn-toolbar .input-group {
float: left;
}
.btn-toolbar > .btn,
.btn-toolbar > .btn-group,
.btn-toolbar > .input-group {
margin-left: 5px;
}
.btn-group > .btn:not(:first-child):not(:last-child):not(.dropdown-toggle) {
border-radius: 0;
}
.btn-group > .btn:first-child {
margin-left: 0;
}
.btn-group > .btn:first-child:not(:last-child):not(.dropdown-toggle) {
<API key>: 0;
<API key>: 0;
}
.btn-group > .btn:last-child:not(:first-child),
.btn-group > .dropdown-toggle:not(:first-child) {
<API key>: 0;
<API key>: 0;
}
.btn-group > .btn-group {
float: left;
}
.btn-group > .btn-group:not(:first-child):not(:last-child) > .btn {
border-radius: 0;
}
.btn-group > .btn-group:first-child > .btn:last-child,
.btn-group > .btn-group:first-child > .dropdown-toggle {
<API key>: 0;
<API key>: 0;
}
.btn-group > .btn-group:last-child > .btn:first-child {
<API key>: 0;
<API key>: 0;
}
.btn-group .dropdown-toggle:active,
.btn-group.open .dropdown-toggle {
outline: 0;
}
.btn-group > .btn + .dropdown-toggle {
padding-right: 8px;
padding-left: 8px;
}
.btn-group > .btn-lg + .dropdown-toggle {
padding-right: 12px;
padding-left: 12px;
}
.btn-group.open .dropdown-toggle {
-webkit-box-shadow: inset 0 3px 5px rgba(0, 0, 0, .125);
box-shadow: inset 0 3px 5px rgba(0, 0, 0, .125);
}
.btn-group.open .dropdown-toggle.btn-link {
-webkit-box-shadow: none;
box-shadow: none;
}
.btn .caret {
margin-left: 0;
}
.btn-lg .caret {
border-width: 5px 5px 0;
border-bottom-width: 0;
}
.dropup .btn-lg .caret {
border-width: 0 5px 5px;
}
.btn-group-vertical > .btn,
.btn-group-vertical > .btn-group,
.btn-group-vertical > .btn-group > .btn {
display: block;
float: none;
width: 100%;
max-width: 100%;
}
.btn-group-vertical > .btn-group > .btn {
float: none;
}
.btn-group-vertical > .btn + .btn,
.btn-group-vertical > .btn + .btn-group,
.btn-group-vertical > .btn-group + .btn,
.btn-group-vertical > .btn-group + .btn-group {
margin-top: -1px;
margin-left: 0;
}
.btn-group-vertical > .btn:not(:first-child):not(:last-child) {
border-radius: 0;
}
.btn-group-vertical > .btn:first-child:not(:last-child) {
<API key>: 4px;
<API key>: 0;
<API key>: 0;
}
.btn-group-vertical > .btn:last-child:not(:first-child) {
<API key>: 0;
<API key>: 0;
<API key>: 4px;
}
.btn-group-vertical > .btn-group:not(:first-child):not(:last-child) > .btn {
border-radius: 0;
}
.btn-group-vertical > .btn-group:first-child:not(:last-child) > .btn:last-child,
.btn-group-vertical > .btn-group:first-child:not(:last-child) > .dropdown-toggle {
<API key>: 0;
<API key>: 0;
}
.btn-group-vertical > .btn-group:last-child:not(:first-child) > .btn:first-child {
<API key>: 0;
<API key>: 0;
}
.btn-group-justified {
display: table;
width: 100%;
table-layout: fixed;
border-collapse: separate;
}
.btn-group-justified > .btn,
.btn-group-justified > .btn-group {
display: table-cell;
float: none;
width: 1%;
}
.btn-group-justified > .btn-group .btn {
width: 100%;
}
.btn-group-justified > .btn-group .dropdown-menu {
left: auto;
}
[data-toggle="buttons"] > .btn > input[type="radio"],
[data-toggle="buttons"] > .btn > input[type="checkbox"] {
position: absolute;
z-index: -1;
filter: alpha(opacity=0);
opacity: 0;
}
.input-group {
position: relative;
display: table;
border-collapse: separate;
}
.input-group[class*="col-"] {
float: none;
padding-right: 0;
padding-left: 0;
}
.input-group .form-control {
position: relative;
z-index: 2;
float: left;
width: 100%;
margin-bottom: 0;
}
.input-group-lg > .form-control,
.input-group-lg > .input-group-addon,
.input-group-lg > .input-group-btn > .btn {
height: 46px;
padding: 10px 16px;
font-size: 18px;
line-height: 1.33;
border-radius: 6px;
}
select.input-group-lg > .form-control,
select.input-group-lg > .input-group-addon,
select.input-group-lg > .input-group-btn > .btn {
height: 46px;
line-height: 46px;
}
textarea.input-group-lg > .form-control,
textarea.input-group-lg > .input-group-addon,
textarea.input-group-lg > .input-group-btn > .btn,
select[multiple].input-group-lg > .form-control,
select[multiple].input-group-lg > .input-group-addon,
select[multiple].input-group-lg > .input-group-btn > .btn {
height: auto;
}
.input-group-sm > .form-control,
.input-group-sm > .input-group-addon,
.input-group-sm > .input-group-btn > .btn {
height: 30px;
padding: 5px 10px;
font-size: 12px;
line-height: 1.5;
border-radius: 3px;
}
select.input-group-sm > .form-control,
select.input-group-sm > .input-group-addon,
select.input-group-sm > .input-group-btn > .btn {
height: 30px;
line-height: 30px;
}
textarea.input-group-sm > .form-control,
textarea.input-group-sm > .input-group-addon,
textarea.input-group-sm > .input-group-btn > .btn,
select[multiple].input-group-sm > .form-control,
select[multiple].input-group-sm > .input-group-addon,
select[multiple].input-group-sm > .input-group-btn > .btn {
height: auto;
}
.input-group-addon,
.input-group-btn,
.input-group .form-control {
display: table-cell;
}
.input-group-addon:not(:first-child):not(:last-child),
.input-group-btn:not(:first-child):not(:last-child),
.input-group .form-control:not(:first-child):not(:last-child) {
border-radius: 0;
}
.input-group-addon,
.input-group-btn {
width: 1%;
white-space: nowrap;
vertical-align: middle;
}
.input-group-addon {
padding: 6px 12px;
font-size: 14px;
font-weight: normal;
line-height: 1;
color: #555;
text-align: center;
background-color: #eee;
border: 1px solid #ccc;
border-radius: 4px;
}
.input-group-addon.input-sm {
padding: 5px 10px;
font-size: 12px;
border-radius: 3px;
}
.input-group-addon.input-lg {
padding: 10px 16px;
font-size: 18px;
border-radius: 6px;
}
.input-group-addon input[type="radio"],
.input-group-addon input[type="checkbox"] {
margin-top: 0;
}
.input-group .form-control:first-child,
.input-group-addon:first-child,
.input-group-btn:first-child > .btn,
.input-group-btn:first-child > .btn-group > .btn,
.input-group-btn:first-child > .dropdown-toggle,
.input-group-btn:last-child > .btn:not(:last-child):not(.dropdown-toggle),
.input-group-btn:last-child > .btn-group:not(:last-child) > .btn {
<API key>: 0;
<API key>: 0;
}
.input-group-addon:first-child {
border-right: 0;
}
.input-group .form-control:last-child,
.input-group-addon:last-child,
.input-group-btn:last-child > .btn,
.input-group-btn:last-child > .btn-group > .btn,
.input-group-btn:last-child > .dropdown-toggle,
.input-group-btn:first-child > .btn:not(:first-child),
.input-group-btn:first-child > .btn-group:not(:first-child) > .btn {
<API key>: 0;
<API key>: 0;
}
.input-group-addon:last-child {
border-left: 0;
}
.input-group-btn {
position: relative;
font-size: 0;
white-space: nowrap;
}
.input-group-btn > .btn {
position: relative;
}
.input-group-btn > .btn + .btn {
margin-left: -1px;
}
.input-group-btn > .btn:hover,
.input-group-btn > .btn:focus,
.input-group-btn > .btn:active {
z-index: 2;
}
.input-group-btn:first-child > .btn,
.input-group-btn:first-child > .btn-group {
margin-right: -1px;
}
.input-group-btn:last-child > .btn,
.input-group-btn:last-child > .btn-group {
margin-left: -1px;
}
.nav {
padding-left: 0;
margin-bottom: 0;
list-style: none;
}
.nav > li {
position: relative;
display: block;
}
.nav > li > a {
position: relative;
display: block;
padding: 10px 15px;
}
.nav > li > a:hover,
.nav > li > a:focus {
text-decoration: none;
background-color: #eee;
}
.nav > li.disabled > a {
color: #777;
}
.nav > li.disabled > a:hover,
.nav > li.disabled > a:focus {
color: #777;
text-decoration: none;
cursor: not-allowed;
background-color: transparent;
}
.nav .open > a,
.nav .open > a:hover,
.nav .open > a:focus {
background-color: #eee;
border-color: #428bca;
}
.nav .nav-divider {
height: 1px;
margin: 9px 0;
overflow: hidden;
background-color: #e5e5e5;
}
.nav > li > a > img {
max-width: none;
}
.nav-tabs {
border-bottom: 1px solid #ddd;
}
.nav-tabs > li {
float: left;
margin-bottom: -1px;
}
.nav-tabs > li > a {
margin-right: 2px;
line-height: 1.42857143;
border: 1px solid transparent;
border-radius: 4px 4px 0 0;
}
.nav-tabs > li > a:hover {
border-color: #eee #eee #ddd;
}
.nav-tabs > li.active > a,
.nav-tabs > li.active > a:hover,
.nav-tabs > li.active > a:focus {
color: #555;
cursor: default;
background-color: #fff;
border: 1px solid #ddd;
border-bottom-color: transparent;
}
.nav-tabs.nav-justified {
width: 100%;
border-bottom: 0;
}
.nav-tabs.nav-justified > li {
float: none;
}
.nav-tabs.nav-justified > li > a {
margin-bottom: 5px;
text-align: center;
}
.nav-tabs.nav-justified > .dropdown .dropdown-menu {
top: auto;
left: auto;
}
@media (min-width: 768px) {
.nav-tabs.nav-justified > li {
display: table-cell;
width: 1%;
}
.nav-tabs.nav-justified > li > a {
margin-bottom: 0;
}
}
.nav-tabs.nav-justified > li > a {
margin-right: 0;
border-radius: 4px;
}
.nav-tabs.nav-justified > .active > a,
.nav-tabs.nav-justified > .active > a:hover,
.nav-tabs.nav-justified > .active > a:focus {
border: 1px solid #ddd;
}
@media (min-width: 768px) {
.nav-tabs.nav-justified > li > a {
border-bottom: 1px solid #ddd;
border-radius: 4px 4px 0 0;
}
.nav-tabs.nav-justified > .active > a,
.nav-tabs.nav-justified > .active > a:hover,
.nav-tabs.nav-justified > .active > a:focus {
border-bottom-color: #fff;
}
}
.nav-pills > li {
float: left;
}
.nav-pills > li > a {
border-radius: 4px;
}
.nav-pills > li + li {
margin-left: 2px;
}
.nav-pills > li.active > a,
.nav-pills > li.active > a:hover,
.nav-pills > li.active > a:focus {
color: #fff;
background-color: #428bca;
}
.nav-stacked > li {
float: none;
}
.nav-stacked > li + li {
margin-top: 2px;
margin-left: 0;
}
.nav-justified {
width: 100%;
}
.nav-justified > li {
float: none;
}
.nav-justified > li > a {
margin-bottom: 5px;
text-align: center;
}
.nav-justified > .dropdown .dropdown-menu {
top: auto;
left: auto;
}
@media (min-width: 768px) {
.nav-justified > li {
display: table-cell;
width: 1%;
}
.nav-justified > li > a {
margin-bottom: 0;
}
}
.nav-tabs-justified {
border-bottom: 0;
}
.nav-tabs-justified > li > a {
margin-right: 0;
border-radius: 4px;
}
.nav-tabs-justified > .active > a,
.nav-tabs-justified > .active > a:hover,
.nav-tabs-justified > .active > a:focus {
border: 1px solid #ddd;
}
@media (min-width: 768px) {
.nav-tabs-justified > li > a {
border-bottom: 1px solid #ddd;
border-radius: 4px 4px 0 0;
}
.nav-tabs-justified > .active > a,
.nav-tabs-justified > .active > a:hover,
.nav-tabs-justified > .active > a:focus {
border-bottom-color: #fff;
}
}
.tab-content > .tab-pane {
display: none;
}
.tab-content > .active {
display: block;
}
.nav-tabs .dropdown-menu {
margin-top: -1px;
<API key>: 0;
<API key>: 0;
}
.navbar {
position: relative;
min-height: 50px;
margin-bottom: 20px;
border: 1px solid transparent;
}
@media (min-width: 768px) {
.navbar {
border-radius: 4px;
}
}
@media (min-width: 768px) {
.navbar-header {
float: left;
}
}
.navbar-collapse {
padding-right: 15px;
padding-left: 15px;
overflow-x: visible;
-<API key>: touch;
border-top: 1px solid transparent;
-webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, .1);
box-shadow: inset 0 1px 0 rgba(255, 255, 255, .1);
}
.navbar-collapse.in {
overflow-y: auto;
}
@media (min-width: 768px) {
.navbar-collapse {
width: auto;
border-top: 0;
-webkit-box-shadow: none;
box-shadow: none;
}
.navbar-collapse.collapse {
display: block !important;
height: auto !important;
padding-bottom: 0;
overflow: visible !important;
}
.navbar-collapse.in {
overflow-y: visible;
}
.navbar-fixed-top .navbar-collapse,
.navbar-static-top .navbar-collapse,
.navbar-fixed-bottom .navbar-collapse {
padding-right: 0;
padding-left: 0;
}
}
.navbar-fixed-top .navbar-collapse,
.navbar-fixed-bottom .navbar-collapse {
max-height: 340px;
}
@media (max-width: 480px) and (orientation: landscape) {
.navbar-fixed-top .navbar-collapse,
.navbar-fixed-bottom .navbar-collapse {
max-height: 200px;
}
}
.container > .navbar-header,
.container-fluid > .navbar-header,
.container > .navbar-collapse,
.container-fluid > .navbar-collapse {
margin-right: -15px;
margin-left: -15px;
}
@media (min-width: 768px) {
.container > .navbar-header,
.container-fluid > .navbar-header,
.container > .navbar-collapse,
.container-fluid > .navbar-collapse {
margin-right: 0;
margin-left: 0;
}
}
.navbar-static-top {
z-index: 1000;
border-width: 0 0 1px;
}
@media (min-width: 768px) {
.navbar-static-top {
border-radius: 0;
}
}
.navbar-fixed-top,
.navbar-fixed-bottom {
position: fixed;
right: 0;
left: 0;
z-index: 1030;
-webkit-transform: translate3d(0, 0, 0);
-o-transform: translate3d(0, 0, 0);
transform: translate3d(0, 0, 0);
}
@media (min-width: 768px) {
.navbar-fixed-top,
.navbar-fixed-bottom {
border-radius: 0;
}
}
.navbar-fixed-top {
top: 0;
border-width: 0 0 1px;
}
.navbar-fixed-bottom {
bottom: 0;
margin-bottom: 0;
border-width: 1px 0 0;
}
.navbar-brand {
float: left;
height: 50px;
padding: 15px 15px;
font-size: 18px;
line-height: 20px;
}
.navbar-brand:hover,
.navbar-brand:focus {
text-decoration: none;
}
@media (min-width: 768px) {
.navbar > .container .navbar-brand,
.navbar > .container-fluid .navbar-brand {
margin-left: -15px;
}
}
.navbar-toggle {
position: relative;
float: right;
padding: 9px 10px;
margin-top: 8px;
margin-right: 15px;
margin-bottom: 8px;
background-color: transparent;
background-image: none;
border: 1px solid transparent;
border-radius: 4px;
}
.navbar-toggle:focus {
outline: 0;
}
.navbar-toggle .icon-bar {
display: block;
width: 22px;
height: 2px;
border-radius: 1px;
}
.navbar-toggle .icon-bar + .icon-bar {
margin-top: 4px;
}
@media (min-width: 768px) {
.navbar-toggle {
display: none;
}
}
.navbar-nav {
margin: 7.5px -15px;
}
.navbar-nav > li > a {
padding-top: 10px;
padding-bottom: 10px;
line-height: 20px;
}
@media (max-width: 767px) {
.navbar-nav .open .dropdown-menu {
position: static;
float: none;
width: auto;
margin-top: 0;
background-color: transparent;
border: 0;
-webkit-box-shadow: none;
box-shadow: none;
}
.navbar-nav .open .dropdown-menu > li > a,
.navbar-nav .open .dropdown-menu .dropdown-header {
padding: 5px 15px 5px 25px;
}
.navbar-nav .open .dropdown-menu > li > a {
line-height: 20px;
}
.navbar-nav .open .dropdown-menu > li > a:hover,
.navbar-nav .open .dropdown-menu > li > a:focus {
background-image: none;
}
}
@media (min-width: 768px) {
.navbar-nav {
float: left;
margin: 0;
}
.navbar-nav > li {
float: left;
}
.navbar-nav > li > a {
padding-top: 15px;
padding-bottom: 15px;
}
.navbar-nav.navbar-right:last-child {
margin-right: -15px;
}
}
@media (min-width: 768px) {
.navbar-left {
float: left !important;
}
.navbar-right {
float: right !important;
}
}
.navbar-form {
padding: 10px 15px;
margin-top: 8px;
margin-right: -15px;
margin-bottom: 8px;
margin-left: -15px;
border-top: 1px solid transparent;
border-bottom: 1px solid transparent;
-webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, .1), 0 1px 0 rgba(255, 255, 255, .1);
box-shadow: inset 0 1px 0 rgba(255, 255, 255, .1), 0 1px 0 rgba(255, 255, 255, .1);
}
@media (min-width: 768px) {
.navbar-form .form-group {
display: inline-block;
margin-bottom: 0;
vertical-align: middle;
}
.navbar-form .form-control {
display: inline-block;
width: auto;
vertical-align: middle;
}
.navbar-form .input-group {
display: inline-table;
vertical-align: middle;
}
.navbar-form .input-group .input-group-addon,
.navbar-form .input-group .input-group-btn,
.navbar-form .input-group .form-control {
width: auto;
}
.navbar-form .input-group > .form-control {
width: 100%;
}
.navbar-form .control-label {
margin-bottom: 0;
vertical-align: middle;
}
.navbar-form .radio,
.navbar-form .checkbox {
display: inline-block;
margin-top: 0;
margin-bottom: 0;
vertical-align: middle;
}
.navbar-form .radio label,
.navbar-form .checkbox label {
padding-left: 0;
}
.navbar-form .radio input[type="radio"],
.navbar-form .checkbox input[type="checkbox"] {
position: relative;
margin-left: 0;
}
.navbar-form .has-feedback .<API key> {
top: 0;
}
}
@media (max-width: 767px) {
.navbar-form .form-group {
margin-bottom: 5px;
}
}
@media (min-width: 768px) {
.navbar-form {
width: auto;
padding-top: 0;
padding-bottom: 0;
margin-right: 0;
margin-left: 0;
border: 0;
-webkit-box-shadow: none;
box-shadow: none;
}
.navbar-form.navbar-right:last-child {
margin-right: -15px;
}
}
.navbar-nav > li > .dropdown-menu {
margin-top: 0;
<API key>: 0;
<API key>: 0;
}
.navbar-fixed-bottom .navbar-nav > li > .dropdown-menu {
<API key>: 0;
<API key>: 0;
}
.navbar-btn {
margin-top: 8px;
margin-bottom: 8px;
}
.navbar-btn.btn-sm {
margin-top: 10px;
margin-bottom: 10px;
}
.navbar-btn.btn-xs {
margin-top: 14px;
margin-bottom: 14px;
}
.navbar-text {
margin-top: 15px;
margin-bottom: 15px;
}
@media (min-width: 768px) {
.navbar-text {
float: left;
margin-right: 15px;
margin-left: 15px;
}
.navbar-text.navbar-right:last-child {
margin-right: 0;
}
}
.navbar-default {
background-color: #f8f8f8;
border-color: #e7e7e7;
}
.navbar-default .navbar-brand {
color: #777;
}
.navbar-default .navbar-brand:hover,
.navbar-default .navbar-brand:focus {
color: #5e5e5e;
background-color: transparent;
}
.navbar-default .navbar-text {
color: #777;
}
.navbar-default .navbar-nav > li > a {
color: #777;
}
.navbar-default .navbar-nav > li > a:hover,
.navbar-default .navbar-nav > li > a:focus {
color: #333;
background-color: transparent;
}
.navbar-default .navbar-nav > .active > a,
.navbar-default .navbar-nav > .active > a:hover,
.navbar-default .navbar-nav > .active > a:focus {
color: #555;
background-color: #e7e7e7;
}
.navbar-default .navbar-nav > .disabled > a,
.navbar-default .navbar-nav > .disabled > a:hover,
.navbar-default .navbar-nav > .disabled > a:focus {
color: #ccc;
background-color: transparent;
}
.navbar-default .navbar-toggle {
border-color: #ddd;
}
.navbar-default .navbar-toggle:hover,
.navbar-default .navbar-toggle:focus {
background-color: #ddd;
}
.navbar-default .navbar-toggle .icon-bar {
background-color: #888;
}
.navbar-default .navbar-collapse,
.navbar-default .navbar-form {
border-color: #e7e7e7;
}
.navbar-default .navbar-nav > .open > a,
.navbar-default .navbar-nav > .open > a:hover,
.navbar-default .navbar-nav > .open > a:focus {
color: #555;
background-color: #e7e7e7;
}
@media (max-width: 767px) {
.navbar-default .navbar-nav .open .dropdown-menu > li > a {
color: #777;
}
.navbar-default .navbar-nav .open .dropdown-menu > li > a:hover,
.navbar-default .navbar-nav .open .dropdown-menu > li > a:focus {
color: #333;
background-color: transparent;
}
.navbar-default .navbar-nav .open .dropdown-menu > .active > a,
.navbar-default .navbar-nav .open .dropdown-menu > .active > a:hover,
.navbar-default .navbar-nav .open .dropdown-menu > .active > a:focus {
color: #555;
background-color: #e7e7e7;
}
.navbar-default .navbar-nav .open .dropdown-menu > .disabled > a,
.navbar-default .navbar-nav .open .dropdown-menu > .disabled > a:hover,
.navbar-default .navbar-nav .open .dropdown-menu > .disabled > a:focus {
color: #ccc;
background-color: transparent;
}
}
.navbar-default .navbar-link {
color: #777;
}
.navbar-default .navbar-link:hover {
color: #333;
}
.navbar-default .btn-link {
color: #777;
}
.navbar-default .btn-link:hover,
.navbar-default .btn-link:focus {
color: #333;
}
.navbar-default .btn-link[disabled]:hover,
fieldset[disabled] .navbar-default .btn-link:hover,
.navbar-default .btn-link[disabled]:focus,
fieldset[disabled] .navbar-default .btn-link:focus {
color: #ccc;
}
.navbar-inverse {
background-color: #222;
border-color: #080808;
}
.navbar-inverse .navbar-brand {
color: #777;
}
.navbar-inverse .navbar-brand:hover,
.navbar-inverse .navbar-brand:focus {
color: #fff;
background-color: transparent;
}
.navbar-inverse .navbar-text {
color: #777;
}
.navbar-inverse .navbar-nav > li > a {
color: #777;
}
.navbar-inverse .navbar-nav > li > a:hover,
.navbar-inverse .navbar-nav > li > a:focus {
color: #fff;
background-color: transparent;
}
.navbar-inverse .navbar-nav > .active > a,
.navbar-inverse .navbar-nav > .active > a:hover,
.navbar-inverse .navbar-nav > .active > a:focus {
color: #fff;
background-color: #080808;
}
.navbar-inverse .navbar-nav > .disabled > a,
.navbar-inverse .navbar-nav > .disabled > a:hover,
.navbar-inverse .navbar-nav > .disabled > a:focus {
color: #444;
background-color: transparent;
}
.navbar-inverse .navbar-toggle {
border-color: #333;
}
.navbar-inverse .navbar-toggle:hover,
.navbar-inverse .navbar-toggle:focus {
background-color: #333;
}
.navbar-inverse .navbar-toggle .icon-bar {
background-color: #fff;
}
.navbar-inverse .navbar-collapse,
.navbar-inverse .navbar-form {
border-color: #101010;
}
.navbar-inverse .navbar-nav > .open > a,
.navbar-inverse .navbar-nav > .open > a:hover,
.navbar-inverse .navbar-nav > .open > a:focus {
color: #fff;
background-color: #080808;
}
@media (max-width: 767px) {
.navbar-inverse .navbar-nav .open .dropdown-menu > .dropdown-header {
border-color: #080808;
}
.navbar-inverse .navbar-nav .open .dropdown-menu .divider {
background-color: #080808;
}
.navbar-inverse .navbar-nav .open .dropdown-menu > li > a {
color: #777;
}
.navbar-inverse .navbar-nav .open .dropdown-menu > li > a:hover,
.navbar-inverse .navbar-nav .open .dropdown-menu > li > a:focus {
color: #fff;
background-color: transparent;
}
.navbar-inverse .navbar-nav .open .dropdown-menu > .active > a,
.navbar-inverse .navbar-nav .open .dropdown-menu > .active > a:hover,
.navbar-inverse .navbar-nav .open .dropdown-menu > .active > a:focus {
color: #fff;
background-color: #080808;
}
.navbar-inverse .navbar-nav .open .dropdown-menu > .disabled > a,
.navbar-inverse .navbar-nav .open .dropdown-menu > .disabled > a:hover,
.navbar-inverse .navbar-nav .open .dropdown-menu > .disabled > a:focus {
color: #444;
background-color: transparent;
}
}
.navbar-inverse .navbar-link {
color: #777;
}
.navbar-inverse .navbar-link:hover {
color: #fff;
}
.navbar-inverse .btn-link {
color: #777;
}
.navbar-inverse .btn-link:hover,
.navbar-inverse .btn-link:focus {
color: #fff;
}
.navbar-inverse .btn-link[disabled]:hover,
fieldset[disabled] .navbar-inverse .btn-link:hover,
.navbar-inverse .btn-link[disabled]:focus,
fieldset[disabled] .navbar-inverse .btn-link:focus {
color: #444;
}
.breadcrumb {
padding: 8px 15px;
margin-bottom: 20px;
list-style: none;
background-color: #f5f5f5;
border-radius: 4px;
}
.breadcrumb > li {
display: inline-block;
}
.breadcrumb > li + li:before {
padding: 0 5px;
color: #ccc;
content: "/\00a0";
}
.breadcrumb > .active {
color: #777;
}
.pagination {
display: inline-block;
padding-left: 0;
margin: 20px 0;
border-radius: 4px;
}
.pagination > li {
display: inline;
}
.pagination > li > a,
.pagination > li > span {
position: relative;
float: left;
padding: 6px 12px;
margin-left: -1px;
line-height: 1.42857143;
color: #428bca;
text-decoration: none;
background-color: #fff;
border: 1px solid #ddd;
}
.pagination > li:first-child > a,
.pagination > li:first-child > span {
margin-left: 0;
<API key>: 4px;
<API key>: 4px;
}
.pagination > li:last-child > a,
.pagination > li:last-child > span {
<API key>: 4px;
<API key>: 4px;
}
.pagination > li > a:hover,
.pagination > li > span:hover,
.pagination > li > a:focus,
.pagination > li > span:focus {
color: #2a6496;
background-color: #eee;
border-color: #ddd;
}
.pagination > .active > a,
.pagination > .active > span,
.pagination > .active > a:hover,
.pagination > .active > span:hover,
.pagination > .active > a:focus,
.pagination > .active > span:focus {
z-index: 2;
color: #fff;
cursor: default;
background-color: #428bca;
border-color: #428bca;
}
.pagination > .disabled > span,
.pagination > .disabled > span:hover,
.pagination > .disabled > span:focus,
.pagination > .disabled > a,
.pagination > .disabled > a:hover,
.pagination > .disabled > a:focus {
color: #777;
cursor: not-allowed;
background-color: #fff;
border-color: #ddd;
}
.pagination-lg > li > a,
.pagination-lg > li > span {
padding: 10px 16px;
font-size: 18px;
}
.pagination-lg > li:first-child > a,
.pagination-lg > li:first-child > span {
<API key>: 6px;
<API key>: 6px;
}
.pagination-lg > li:last-child > a,
.pagination-lg > li:last-child > span {
<API key>: 6px;
<API key>: 6px;
}
.pagination-sm > li > a,
.pagination-sm > li > span {
padding: 5px 10px;
font-size: 12px;
}
.pagination-sm > li:first-child > a,
.pagination-sm > li:first-child > span {
<API key>: 3px;
<API key>: 3px;
}
.pagination-sm > li:last-child > a,
.pagination-sm > li:last-child > span {
<API key>: 3px;
<API key>: 3px;
}
.pager {
padding-left: 0;
margin: 20px 0;
text-align: center;
list-style: none;
}
.pager li {
display: inline;
}
.pager li > a,
.pager li > span {
display: inline-block;
padding: 5px 14px;
background-color: #fff;
border: 1px solid #ddd;
border-radius: 15px;
}
.pager li > a:hover,
.pager li > a:focus {
text-decoration: none;
background-color: #eee;
}
.pager .next > a,
.pager .next > span {
float: right;
}
.pager .previous > a,
.pager .previous > span {
float: left;
}
.pager .disabled > a,
.pager .disabled > a:hover,
.pager .disabled > a:focus,
.pager .disabled > span {
color: #777;
cursor: not-allowed;
background-color: #fff;
}
.label {
display: inline;
padding: .2em .6em .3em;
font-size: 75%;
font-weight: bold;
line-height: 1;
color: #fff;
text-align: center;
white-space: nowrap;
vertical-align: baseline;
border-radius: .25em;
}
a.label:hover,
a.label:focus {
color: #fff;
text-decoration: none;
cursor: pointer;
}
.label:empty {
display: none;
}
.btn .label {
position: relative;
top: -1px;
}
.label-default {
background-color: #777;
}
.label-default[href]:hover,
.label-default[href]:focus {
background-color: #5e5e5e;
}
.label-primary {
background-color: #428bca;
}
.label-primary[href]:hover,
.label-primary[href]:focus {
background-color: #3071a9;
}
.label-success {
background-color: #5cb85c;
}
.label-success[href]:hover,
.label-success[href]:focus {
background-color: #449d44;
}
.label-info {
background-color: #5bc0de;
}
.label-info[href]:hover,
.label-info[href]:focus {
background-color: #31b0d5;
}
.label-warning {
background-color: #f0ad4e;
}
.label-warning[href]:hover,
.label-warning[href]:focus {
background-color: #ec971f;
}
.label-danger {
background-color: #d9534f;
}
.label-danger[href]:hover,
.label-danger[href]:focus {
background-color: #c9302c;
}
.badge {
display: inline-block;
min-width: 10px;
padding: 3px 7px;
font-size: 12px;
font-weight: bold;
line-height: 1;
color: #fff;
text-align: center;
white-space: nowrap;
vertical-align: baseline;
background-color: #777;
border-radius: 10px;
}
.badge:empty {
display: none;
}
.btn .badge {
position: relative;
top: -1px;
}
.btn-xs .badge {
top: 0;
padding: 1px 5px;
}
a.badge:hover,
a.badge:focus {
color: #fff;
text-decoration: none;
cursor: pointer;
}
a.list-group-item.active > .badge,
.nav-pills > .active > a > .badge {
color: #428bca;
background-color: #fff;
}
.nav-pills > li > a > .badge {
margin-left: 3px;
}
.jumbotron {
padding: 30px;
margin-bottom: 30px;
color: inherit;
background-color: #eee;
}
.jumbotron h1,
.jumbotron .h1 {
color: inherit;
}
.jumbotron p {
margin-bottom: 15px;
font-size: 21px;
font-weight: 200;
}
.jumbotron > hr {
border-top-color: #d5d5d5;
}
.container .jumbotron {
border-radius: 6px;
}
.jumbotron .container {
max-width: 100%;
}
@media screen and (min-width: 768px) {
.jumbotron {
padding-top: 48px;
padding-bottom: 48px;
}
.container .jumbotron {
padding-right: 60px;
padding-left: 60px;
}
.jumbotron h1,
.jumbotron .h1 {
font-size: 63px;
}
}
.thumbnail {
display: block;
padding: 4px;
margin-bottom: 20px;
line-height: 1.42857143;
background-color: #fff;
border: 1px solid #ddd;
border-radius: 4px;
-webkit-transition: all .2s ease-in-out;
-o-transition: all .2s ease-in-out;
transition: all .2s ease-in-out;
}
.thumbnail > img,
.thumbnail a > img {
margin-right: auto;
margin-left: auto;
}
a.thumbnail:hover,
a.thumbnail:focus,
a.thumbnail.active {
border-color: #428bca;
}
.thumbnail .caption {
padding: 9px;
color: #333;
}
.alert {
padding: 15px;
margin-bottom: 20px;
border: 1px solid transparent;
border-radius: 4px;
}
.alert h4 {
margin-top: 0;
color: inherit;
}
.alert .alert-link {
font-weight: bold;
}
.alert > p,
.alert > ul {
margin-bottom: 0;
}
.alert > p + p {
margin-top: 5px;
}
.alert-dismissable,
.alert-dismissible {
padding-right: 35px;
}
.alert-dismissable .close,
.alert-dismissible .close {
position: relative;
top: -2px;
right: -21px;
color: inherit;
}
.alert-success {
color: #3c763d;
background-color: #dff0d8;
border-color: #d6e9c6;
}
.alert-success hr {
border-top-color: #c9e2b3;
}
.alert-success .alert-link {
color: #2b542c;
}
.alert-info {
color: #31708f;
background-color: #d9edf7;
border-color: #bce8f1;
}
.alert-info hr {
border-top-color: #a6e1ec;
}
.alert-info .alert-link {
color: #245269;
}
.alert-warning {
color: #8a6d3b;
background-color: #fcf8e3;
border-color: #faebcc;
}
.alert-warning hr {
border-top-color: #f7e1b5;
}
.alert-warning .alert-link {
color: #66512c;
}
.alert-danger {
color: #a94442;
background-color: #f2dede;
border-color: #ebccd1;
}
.alert-danger hr {
border-top-color: #e4b9c0;
}
.alert-danger .alert-link {
color: #843534;
}
@-webkit-keyframes <API key> {
from {
background-position: 40px 0;
}
to {
background-position: 0 0;
}
}
@-o-keyframes <API key> {
from {
background-position: 40px 0;
}
to {
background-position: 0 0;
}
}
@keyframes <API key> {
from {
background-position: 40px 0;
}
to {
background-position: 0 0;
}
}
.progress {
height: 20px;
margin-bottom: 20px;
overflow: hidden;
background-color: #f5f5f5;
border-radius: 4px;
-webkit-box-shadow: inset 0 1px 2px rgba(0, 0, 0, .1);
box-shadow: inset 0 1px 2px rgba(0, 0, 0, .1);
}
.progress-bar {
float: left;
width: 0;
height: 100%;
font-size: 12px;
line-height: 20px;
color: #fff;
text-align: center;
background-color: #428bca;
-webkit-box-shadow: inset 0 -1px 0 rgba(0, 0, 0, .15);
box-shadow: inset 0 -1px 0 rgba(0, 0, 0, .15);
-webkit-transition: width .6s ease;
-o-transition: width .6s ease;
transition: width .6s ease;
}
.progress-striped .progress-bar,
.<API key> {
background-image: -<API key>(45deg, rgba(255, 255, 255, .15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, .15) 50%, rgba(255, 255, 255, .15) 75%, transparent 75%, transparent);
background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, .15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, .15) 50%, rgba(255, 255, 255, .15) 75%, transparent 75%, transparent);
background-image: linear-gradient(45deg, rgba(255, 255, 255, .15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, .15) 50%, rgba(255, 255, 255, .15) 75%, transparent 75%, transparent);
-<API key>: 40px 40px;
background-size: 40px 40px;
}
.progress.active .progress-bar,
.progress-bar.active {
-webkit-animation: <API key> 2s linear infinite;
-o-animation: <API key> 2s linear infinite;
animation: <API key> 2s linear infinite;
}
.progress-bar[aria-valuenow="1"],
.progress-bar[aria-valuenow="2"] {
min-width: 30px;
}
.progress-bar[aria-valuenow="0"] {
min-width: 30px;
color: #777;
background-color: transparent;
background-image: none;
-webkit-box-shadow: none;
box-shadow: none;
}
.<API key> {
background-color: #5cb85c;
}
.progress-striped .<API key> {
background-image: -<API key>(45deg, rgba(255, 255, 255, .15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, .15) 50%, rgba(255, 255, 255, .15) 75%, transparent 75%, transparent);
background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, .15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, .15) 50%, rgba(255, 255, 255, .15) 75%, transparent 75%, transparent);
background-image: linear-gradient(45deg, rgba(255, 255, 255, .15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, .15) 50%, rgba(255, 255, 255, .15) 75%, transparent 75%, transparent);
}
.progress-bar-info {
background-color: #5bc0de;
}
.progress-striped .progress-bar-info {
background-image: -<API key>(45deg, rgba(255, 255, 255, .15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, .15) 50%, rgba(255, 255, 255, .15) 75%, transparent 75%, transparent);
background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, .15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, .15) 50%, rgba(255, 255, 255, .15) 75%, transparent 75%, transparent);
background-image: linear-gradient(45deg, rgba(255, 255, 255, .15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, .15) 50%, rgba(255, 255, 255, .15) 75%, transparent 75%, transparent);
}
.<API key> {
background-color: #f0ad4e;
}
.progress-striped .<API key> {
background-image: -<API key>(45deg, rgba(255, 255, 255, .15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, .15) 50%, rgba(255, 255, 255, .15) 75%, transparent 75%, transparent);
background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, .15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, .15) 50%, rgba(255, 255, 255, .15) 75%, transparent 75%, transparent);
background-image: linear-gradient(45deg, rgba(255, 255, 255, .15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, .15) 50%, rgba(255, 255, 255, .15) 75%, transparent 75%, transparent);
}
.progress-bar-danger {
background-color: #d9534f;
}
.progress-striped .progress-bar-danger {
background-image: -<API key>(45deg, rgba(255, 255, 255, .15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, .15) 50%, rgba(255, 255, 255, .15) 75%, transparent 75%, transparent);
background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, .15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, .15) 50%, rgba(255, 255, 255, .15) 75%, transparent 75%, transparent);
background-image: linear-gradient(45deg, rgba(255, 255, 255, .15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, .15) 50%, rgba(255, 255, 255, .15) 75%, transparent 75%, transparent);
}
.media,
.media-body {
overflow: hidden;
zoom: 1;
}
.media,
.media .media {
margin-top: 15px;
}
.media:first-child {
margin-top: 0;
}
.media-object {
display: block;
}
.media-heading {
margin: 0 0 5px;
}
.media > .pull-left {
margin-right: 10px;
}
.media > .pull-right {
margin-left: 10px;
}
.media-list {
padding-left: 0;
list-style: none;
}
.list-group {
padding-left: 0;
margin-bottom: 20px;
}
.list-group-item {
position: relative;
display: block;
padding: 10px 15px;
margin-bottom: -1px;
background-color: #fff;
border: 1px solid #ddd;
}
.list-group-item:first-child {
<API key>: 4px;
<API key>: 4px;
}
.list-group-item:last-child {
margin-bottom: 0;
<API key>: 4px;
<API key>: 4px;
}
.list-group-item > .badge {
float: right;
}
.list-group-item > .badge + .badge {
margin-right: 5px;
}
a.list-group-item {
color: #555;
}
a.list-group-item .<API key> {
color: #333;
}
a.list-group-item:hover,
a.list-group-item:focus {
color: #555;
text-decoration: none;
background-color: #f5f5f5;
}
.list-group-item.disabled,
.list-group-item.disabled:hover,
.list-group-item.disabled:focus {
color: #777;
background-color: #eee;
}
.list-group-item.disabled .<API key>,
.list-group-item.disabled:hover .<API key>,
.list-group-item.disabled:focus .<API key> {
color: inherit;
}
.list-group-item.disabled .<API key>,
.list-group-item.disabled:hover .<API key>,
.list-group-item.disabled:focus .<API key> {
color: #777;
}
.list-group-item.active,
.list-group-item.active:hover,
.list-group-item.active:focus {
z-index: 2;
color: #fff;
background-color: #428bca;
border-color: #428bca;
}
.list-group-item.active .<API key>,
.list-group-item.active:hover .<API key>,
.list-group-item.active:focus .<API key>,
.list-group-item.active .<API key> > small,
.list-group-item.active:hover .<API key> > small,
.list-group-item.active:focus .<API key> > small,
.list-group-item.active .<API key> > .small,
.list-group-item.active:hover .<API key> > .small,
.list-group-item.active:focus .<API key> > .small {
color: inherit;
}
.list-group-item.active .<API key>,
.list-group-item.active:hover .<API key>,
.list-group-item.active:focus .<API key> {
color: #e1edf7;
}
.<API key> {
color: #3c763d;
background-color: #dff0d8;
}
a.<API key> {
color: #3c763d;
}
a.<API key> .<API key> {
color: inherit;
}
a.<API key>:hover,
a.<API key>:focus {
color: #3c763d;
background-color: #d0e9c6;
}
a.<API key>.active,
a.<API key>.active:hover,
a.<API key>.active:focus {
color: #fff;
background-color: #3c763d;
border-color: #3c763d;
}
.<API key> {
color: #31708f;
background-color: #d9edf7;
}
a.<API key> {
color: #31708f;
}
a.<API key> .<API key> {
color: inherit;
}
a.<API key>:hover,
a.<API key>:focus {
color: #31708f;
background-color: #c4e3f3;
}
a.<API key>.active,
a.<API key>.active:hover,
a.<API key>.active:focus {
color: #fff;
background-color: #31708f;
border-color: #31708f;
}
.<API key> {
color: #8a6d3b;
background-color: #fcf8e3;
}
a.<API key> {
color: #8a6d3b;
}
a.<API key> .<API key> {
color: inherit;
}
a.<API key>:hover,
a.<API key>:focus {
color: #8a6d3b;
background-color: #faf2cc;
}
a.<API key>.active,
a.<API key>.active:hover,
a.<API key>.active:focus {
color: #fff;
background-color: #8a6d3b;
border-color: #8a6d3b;
}
.<API key> {
color: #a94442;
background-color: #f2dede;
}
a.<API key> {
color: #a94442;
}
a.<API key> .<API key> {
color: inherit;
}
a.<API key>:hover,
a.<API key>:focus {
color: #a94442;
background-color: #ebcccc;
}
a.<API key>.active,
a.<API key>.active:hover,
a.<API key>.active:focus {
color: #fff;
background-color: #a94442;
border-color: #a94442;
}
.<API key> {
margin-top: 0;
margin-bottom: 5px;
}
.<API key> {
margin-bottom: 0;
line-height: 1.3;
}
.panel {
margin-bottom: 20px;
background-color: #fff;
border: 1px solid transparent;
border-radius: 4px;
-webkit-box-shadow: 0 1px 1px rgba(0, 0, 0, .05);
box-shadow: 0 1px 1px rgba(0, 0, 0, .05);
}
.panel-body {
padding: 15px;
}
.panel-heading {
padding: 10px 15px;
border-bottom: 1px solid transparent;
<API key>: 3px;
<API key>: 3px;
}
.panel-heading > .dropdown .dropdown-toggle {
color: inherit;
}
.panel-title {
margin-top: 0;
margin-bottom: 0;
font-size: 16px;
color: inherit;
}
.panel-title > a {
color: inherit;
}
.panel-footer {
padding: 10px 15px;
background-color: #f5f5f5;
border-top: 1px solid #ddd;
<API key>: 3px;
<API key>: 3px;
}
.panel > .list-group {
margin-bottom: 0;
}
.panel > .list-group .list-group-item {
border-width: 1px 0;
border-radius: 0;
}
.panel > .list-group:first-child .list-group-item:first-child {
border-top: 0;
<API key>: 3px;
<API key>: 3px;
}
.panel > .list-group:last-child .list-group-item:last-child {
border-bottom: 0;
<API key>: 3px;
<API key>: 3px;
}
.panel-heading + .list-group .list-group-item:first-child {
border-top-width: 0;
}
.list-group + .panel-footer {
border-top-width: 0;
}
.panel > .table,
.panel > .table-responsive > .table,
.panel > .panel-collapse > .table {
margin-bottom: 0;
}
.panel > .table:first-child,
.panel > .table-responsive:first-child > .table:first-child {
<API key>: 3px;
<API key>: 3px;
}
.panel > .table:first-child > thead:first-child > tr:first-child td:first-child,
.panel > .table-responsive:first-child > .table:first-child > thead:first-child > tr:first-child td:first-child,
.panel > .table:first-child > tbody:first-child > tr:first-child td:first-child,
.panel > .table-responsive:first-child > .table:first-child > tbody:first-child > tr:first-child td:first-child,
.panel > .table:first-child > thead:first-child > tr:first-child th:first-child,
.panel > .table-responsive:first-child > .table:first-child > thead:first-child > tr:first-child th:first-child,
.panel > .table:first-child > tbody:first-child > tr:first-child th:first-child,
.panel > .table-responsive:first-child > .table:first-child > tbody:first-child > tr:first-child th:first-child {
<API key>: 3px;
}
.panel > .table:first-child > thead:first-child > tr:first-child td:last-child,
.panel > .table-responsive:first-child > .table:first-child > thead:first-child > tr:first-child td:last-child,
.panel > .table:first-child > tbody:first-child > tr:first-child td:last-child,
.panel > .table-responsive:first-child > .table:first-child > tbody:first-child > tr:first-child td:last-child,
.panel > .table:first-child > thead:first-child > tr:first-child th:last-child,
.panel > .table-responsive:first-child > .table:first-child > thead:first-child > tr:first-child th:last-child,
.panel > .table:first-child > tbody:first-child > tr:first-child th:last-child,
.panel > .table-responsive:first-child > .table:first-child > tbody:first-child > tr:first-child th:last-child {
<API key>: 3px;
}
.panel > .table:last-child,
.panel > .table-responsive:last-child > .table:last-child {
<API key>: 3px;
<API key>: 3px;
}
.panel > .table:last-child > tbody:last-child > tr:last-child td:first-child,
.panel > .table-responsive:last-child > .table:last-child > tbody:last-child > tr:last-child td:first-child,
.panel > .table:last-child > tfoot:last-child > tr:last-child td:first-child,
.panel > .table-responsive:last-child > .table:last-child > tfoot:last-child > tr:last-child td:first-child,
.panel > .table:last-child > tbody:last-child > tr:last-child th:first-child,
.panel > .table-responsive:last-child > .table:last-child > tbody:last-child > tr:last-child th:first-child,
.panel > .table:last-child > tfoot:last-child > tr:last-child th:first-child,
.panel > .table-responsive:last-child > .table:last-child > tfoot:last-child > tr:last-child th:first-child {
<API key>: 3px;
}
.panel > .table:last-child > tbody:last-child > tr:last-child td:last-child,
.panel > .table-responsive:last-child > .table:last-child > tbody:last-child > tr:last-child td:last-child,
.panel > .table:last-child > tfoot:last-child > tr:last-child td:last-child,
.panel > .table-responsive:last-child > .table:last-child > tfoot:last-child > tr:last-child td:last-child,
.panel > .table:last-child > tbody:last-child > tr:last-child th:last-child,
.panel > .table-responsive:last-child > .table:last-child > tbody:last-child > tr:last-child th:last-child,
.panel > .table:last-child > tfoot:last-child > tr:last-child th:last-child,
.panel > .table-responsive:last-child > .table:last-child > tfoot:last-child > tr:last-child th:last-child {
<API key>: 3px;
}
.panel > .panel-body + .table,
.panel > .panel-body + .table-responsive {
border-top: 1px solid #ddd;
}
.panel > .table > tbody:first-child > tr:first-child th,
.panel > .table > tbody:first-child > tr:first-child td {
border-top: 0;
}
.panel > .table-bordered,
.panel > .table-responsive > .table-bordered {
border: 0;
}
.panel > .table-bordered > thead > tr > th:first-child,
.panel > .table-responsive > .table-bordered > thead > tr > th:first-child,
.panel > .table-bordered > tbody > tr > th:first-child,
.panel > .table-responsive > .table-bordered > tbody > tr > th:first-child,
.panel > .table-bordered > tfoot > tr > th:first-child,
.panel > .table-responsive > .table-bordered > tfoot > tr > th:first-child,
.panel > .table-bordered > thead > tr > td:first-child,
.panel > .table-responsive > .table-bordered > thead > tr > td:first-child,
.panel > .table-bordered > tbody > tr > td:first-child,
.panel > .table-responsive > .table-bordered > tbody > tr > td:first-child,
.panel > .table-bordered > tfoot > tr > td:first-child,
.panel > .table-responsive > .table-bordered > tfoot > tr > td:first-child {
border-left: 0;
}
.panel > .table-bordered > thead > tr > th:last-child,
.panel > .table-responsive > .table-bordered > thead > tr > th:last-child,
.panel > .table-bordered > tbody > tr > th:last-child,
.panel > .table-responsive > .table-bordered > tbody > tr > th:last-child,
.panel > .table-bordered > tfoot > tr > th:last-child,
.panel > .table-responsive > .table-bordered > tfoot > tr > th:last-child,
.panel > .table-bordered > thead > tr > td:last-child,
.panel > .table-responsive > .table-bordered > thead > tr > td:last-child,
.panel > .table-bordered > tbody > tr > td:last-child,
.panel > .table-responsive > .table-bordered > tbody > tr > td:last-child,
.panel > .table-bordered > tfoot > tr > td:last-child,
.panel > .table-responsive > .table-bordered > tfoot > tr > td:last-child {
border-right: 0;
}
.panel > .table-bordered > thead > tr:first-child > td,
.panel > .table-responsive > .table-bordered > thead > tr:first-child > td,
.panel > .table-bordered > tbody > tr:first-child > td,
.panel > .table-responsive > .table-bordered > tbody > tr:first-child > td,
.panel > .table-bordered > thead > tr:first-child > th,
.panel > .table-responsive > .table-bordered > thead > tr:first-child > th,
.panel > .table-bordered > tbody > tr:first-child > th,
.panel > .table-responsive > .table-bordered > tbody > tr:first-child > th {
border-bottom: 0;
}
.panel > .table-bordered > tbody > tr:last-child > td,
.panel > .table-responsive > .table-bordered > tbody > tr:last-child > td,
.panel > .table-bordered > tfoot > tr:last-child > td,
.panel > .table-responsive > .table-bordered > tfoot > tr:last-child > td,
.panel > .table-bordered > tbody > tr:last-child > th,
.panel > .table-responsive > .table-bordered > tbody > tr:last-child > th,
.panel > .table-bordered > tfoot > tr:last-child > th,
.panel > .table-responsive > .table-bordered > tfoot > tr:last-child > th {
border-bottom: 0;
}
.panel > .table-responsive {
margin-bottom: 0;
border: 0;
}
.panel-group {
margin-bottom: 20px;
}
.panel-group .panel {
margin-bottom: 0;
border-radius: 4px;
}
.panel-group .panel + .panel {
margin-top: 5px;
}
.panel-group .panel-heading {
border-bottom: 0;
}
.panel-group .panel-heading + .panel-collapse > .panel-body {
border-top: 1px solid #ddd;
}
.panel-group .panel-footer {
border-top: 0;
}
.panel-group .panel-footer + .panel-collapse .panel-body {
border-bottom: 1px solid #ddd;
}
.panel-default {
border-color: #ddd;
}
.panel-default > .panel-heading {
color: #333;
background-color: #f5f5f5;
border-color: #ddd;
}
.panel-default > .panel-heading + .panel-collapse > .panel-body {
border-top-color: #ddd;
}
.panel-default > .panel-heading .badge {
color: #f5f5f5;
background-color: #333;
}
.panel-default > .panel-footer + .panel-collapse > .panel-body {
border-bottom-color: #ddd;
}
.panel-primary {
border-color: #428bca;
}
.panel-primary > .panel-heading {
color: #fff;
background-color: #428bca;
border-color: #428bca;
}
.panel-primary > .panel-heading + .panel-collapse > .panel-body {
border-top-color: #428bca;
}
.panel-primary > .panel-heading .badge {
color: #428bca;
background-color: #fff;
}
.panel-primary > .panel-footer + .panel-collapse > .panel-body {
border-bottom-color: #428bca;
}
.panel-success {
border-color: #d6e9c6;
}
.panel-success > .panel-heading {
color: #3c763d;
background-color: #dff0d8;
border-color: #d6e9c6;
}
.panel-success > .panel-heading + .panel-collapse > .panel-body {
border-top-color: #d6e9c6;
}
.panel-success > .panel-heading .badge {
color: #dff0d8;
background-color: #3c763d;
}
.panel-success > .panel-footer + .panel-collapse > .panel-body {
border-bottom-color: #d6e9c6;
}
.panel-info {
border-color: #bce8f1;
}
.panel-info > .panel-heading {
color: #31708f;
background-color: #d9edf7;
border-color: #bce8f1;
}
.panel-info > .panel-heading + .panel-collapse > .panel-body {
border-top-color: #bce8f1;
}
.panel-info > .panel-heading .badge {
color: #d9edf7;
background-color: #31708f;
}
.panel-info > .panel-footer + .panel-collapse > .panel-body {
border-bottom-color: #bce8f1;
}
.panel-warning {
border-color: #faebcc;
}
.panel-warning > .panel-heading {
color: #8a6d3b;
background-color: #fcf8e3;
border-color: #faebcc;
}
.panel-warning > .panel-heading + .panel-collapse > .panel-body {
border-top-color: #faebcc;
}
.panel-warning > .panel-heading .badge {
color: #fcf8e3;
background-color: #8a6d3b;
}
.panel-warning > .panel-footer + .panel-collapse > .panel-body {
border-bottom-color: #faebcc;
}
.panel-danger {
border-color: #ebccd1;
}
.panel-danger > .panel-heading {
color: #a94442;
background-color: #f2dede;
border-color: #ebccd1;
}
.panel-danger > .panel-heading + .panel-collapse > .panel-body {
border-top-color: #ebccd1;
}
.panel-danger > .panel-heading .badge {
color: #f2dede;
background-color: #a94442;
}
.panel-danger > .panel-footer + .panel-collapse > .panel-body {
border-bottom-color: #ebccd1;
}
.embed-responsive {
position: relative;
display: block;
height: 0;
padding: 0;
overflow: hidden;
}
.embed-responsive .<API key>,
.embed-responsive iframe,
.embed-responsive embed,
.embed-responsive object {
position: absolute;
top: 0;
bottom: 0;
left: 0;
width: 100%;
height: 100%;
border: 0;
}
.embed-responsive.<API key> {
padding-bottom: 56.25%;
}
.embed-responsive.<API key> {
padding-bottom: 75%;
}
.well {
min-height: 20px;
padding: 19px;
margin-bottom: 20px;
background-color: #f5f5f5;
border: 1px solid #e3e3e3;
border-radius: 4px;
-webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, .05);
box-shadow: inset 0 1px 1px rgba(0, 0, 0, .05);
}
.well blockquote {
border-color: #ddd;
border-color: rgba(0, 0, 0, .15);
}
.well-lg {
padding: 24px;
border-radius: 6px;
}
.well-sm {
padding: 9px;
border-radius: 3px;
}
.close {
float: right;
font-size: 21px;
font-weight: bold;
line-height: 1;
color: #000;
text-shadow: 0 1px 0 #fff;
filter: alpha(opacity=20);
opacity: .2;
}
.close:hover,
.close:focus {
color: #000;
text-decoration: none;
cursor: pointer;
filter: alpha(opacity=50);
opacity: .5;
}
button.close {
-webkit-appearance: none;
padding: 0;
cursor: pointer;
background: transparent;
border: 0;
}
.modal-open {
overflow: hidden;
}
.modal {
position: fixed;
top: 0;
right: 0;
bottom: 0;
left: 0;
z-index: 1050;
display: none;
overflow: hidden;
-<API key>: touch;
outline: 0;
}
.modal.fade .modal-dialog {
-webkit-transition: -webkit-transform .3s ease-out;
-o-transition: -o-transform .3s ease-out;
transition: transform .3s ease-out;
-webkit-transform: translate3d(0, -25%, 0);
-o-transform: translate3d(0, -25%, 0);
transform: translate3d(0, -25%, 0);
}
.modal.in .modal-dialog {
-webkit-transform: translate3d(0, 0, 0);
-o-transform: translate3d(0, 0, 0);
transform: translate3d(0, 0, 0);
}
.modal-open .modal {
overflow-x: hidden;
overflow-y: auto;
}
.modal-dialog {
position: relative;
width: auto;
margin: 10px;
}
.modal-content {
position: relative;
background-color: #fff;
-<API key>: padding-box;
background-clip: padding-box;
border: 1px solid #999;
border: 1px solid rgba(0, 0, 0, .2);
border-radius: 6px;
outline: 0;
-webkit-box-shadow: 0 3px 9px rgba(0, 0, 0, .5);
box-shadow: 0 3px 9px rgba(0, 0, 0, .5);
}
.modal-backdrop {
position: fixed;
top: 0;
right: 0;
bottom: 0;
left: 0;
z-index: 1040;
background-color: #000;
}
.modal-backdrop.fade {
filter: alpha(opacity=0);
opacity: 0;
}
.modal-backdrop.in {
filter: alpha(opacity=50);
opacity: .5;
}
.modal-header {
min-height: 16.42857143px;
padding: 15px;
border-bottom: 1px solid #e5e5e5;
}
.modal-header .close {
margin-top: -2px;
}
.modal-title {
margin: 0;
line-height: 1.42857143;
}
.modal-body {
position: relative;
padding: 15px;
}
.modal-footer {
padding: 15px;
text-align: right;
border-top: 1px solid #e5e5e5;
}
.modal-footer .btn + .btn {
margin-bottom: 0;
margin-left: 5px;
}
.modal-footer .btn-group .btn + .btn {
margin-left: -1px;
}
.modal-footer .btn-block + .btn-block {
margin-left: 0;
}
.<API key> {
position: absolute;
top: -9999px;
width: 50px;
height: 50px;
overflow: scroll;
}
@media (min-width: 768px) {
.modal-dialog {
width: 600px;
margin: 30px auto;
}
.modal-content {
-webkit-box-shadow: 0 5px 15px rgba(0, 0, 0, .5);
box-shadow: 0 5px 15px rgba(0, 0, 0, .5);
}
.modal-sm {
width: 300px;
}
}
@media (min-width: 992px) {
.modal-lg {
width: 900px;
}
}
.tooltip {
position: absolute;
z-index: 1070;
display: block;
font-size: 12px;
line-height: 1.4;
visibility: visible;
filter: alpha(opacity=0);
opacity: 0;
}
.tooltip.in {
filter: alpha(opacity=90);
opacity: .9;
}
.tooltip.top {
padding: 5px 0;
margin-top: -3px;
}
.tooltip.right {
padding: 0 5px;
margin-left: 3px;
}
.tooltip.bottom {
padding: 5px 0;
margin-top: 3px;
}
.tooltip.left {
padding: 0 5px;
margin-left: -3px;
}
.tooltip-inner {
max-width: 200px;
padding: 3px 8px;
color: #fff;
text-align: center;
text-decoration: none;
background-color: #000;
border-radius: 4px;
}
.tooltip-arrow {
position: absolute;
width: 0;
height: 0;
border-color: transparent;
border-style: solid;
}
.tooltip.top .tooltip-arrow {
bottom: 0;
left: 50%;
margin-left: -5px;
border-width: 5px 5px 0;
border-top-color: #000;
}
.tooltip.top-left .tooltip-arrow {
bottom: 0;
left: 5px;
border-width: 5px 5px 0;
border-top-color: #000;
}
.tooltip.top-right .tooltip-arrow {
right: 5px;
bottom: 0;
border-width: 5px 5px 0;
border-top-color: #000;
}
.tooltip.right .tooltip-arrow {
top: 50%;
left: 0;
margin-top: -5px;
border-width: 5px 5px 5px 0;
border-right-color: #000;
}
.tooltip.left .tooltip-arrow {
top: 50%;
right: 0;
margin-top: -5px;
border-width: 5px 0 5px 5px;
border-left-color: #000;
}
.tooltip.bottom .tooltip-arrow {
top: 0;
left: 50%;
margin-left: -5px;
border-width: 0 5px 5px;
border-bottom-color: #000;
}
.tooltip.bottom-left .tooltip-arrow {
top: 0;
left: 5px;
border-width: 0 5px 5px;
border-bottom-color: #000;
}
.tooltip.bottom-right .tooltip-arrow {
top: 0;
right: 5px;
border-width: 0 5px 5px;
border-bottom-color: #000;
}
.popover {
position: absolute;
top: 0;
left: 0;
z-index: 1060;
display: none;
max-width: 276px;
padding: 1px;
text-align: left;
white-space: normal;
background-color: #fff;
-<API key>: padding-box;
background-clip: padding-box;
border: 1px solid #ccc;
border: 1px solid rgba(0, 0, 0, .2);
border-radius: 6px;
-webkit-box-shadow: 0 5px 10px rgba(0, 0, 0, .2);
box-shadow: 0 5px 10px rgba(0, 0, 0, .2);
}
.popover.top {
margin-top: -10px;
}
.popover.right {
margin-left: 10px;
}
.popover.bottom {
margin-top: 10px;
}
.popover.left {
margin-left: -10px;
}
.popover-title {
padding: 8px 14px;
margin: 0;
font-size: 14px;
font-weight: normal;
line-height: 18px;
background-color: #f7f7f7;
border-bottom: 1px solid #ebebeb;
border-radius: 5px 5px 0 0;
}
.popover-content {
padding: 9px 14px;
}
.popover > .arrow,
.popover > .arrow:after {
position: absolute;
display: block;
width: 0;
height: 0;
border-color: transparent;
border-style: solid;
}
.popover > .arrow {
border-width: 11px;
}
.popover > .arrow:after {
content: "";
border-width: 10px;
}
.popover.top > .arrow {
bottom: -11px;
left: 50%;
margin-left: -11px;
border-top-color: #999;
border-top-color: rgba(0, 0, 0, .25);
border-bottom-width: 0;
}
.popover.top > .arrow:after {
bottom: 1px;
margin-left: -10px;
content: " ";
border-top-color: #fff;
border-bottom-width: 0;
}
.popover.right > .arrow {
top: 50%;
left: -11px;
margin-top: -11px;
border-right-color: #999;
border-right-color: rgba(0, 0, 0, .25);
border-left-width: 0;
}
.popover.right > .arrow:after {
bottom: -10px;
left: 1px;
content: " ";
border-right-color: #fff;
border-left-width: 0;
}
.popover.bottom > .arrow {
top: -11px;
left: 50%;
margin-left: -11px;
border-top-width: 0;
border-bottom-color: #999;
border-bottom-color: rgba(0, 0, 0, .25);
}
.popover.bottom > .arrow:after {
top: 1px;
margin-left: -10px;
content: " ";
border-top-width: 0;
border-bottom-color: #fff;
}
.popover.left > .arrow {
top: 50%;
right: -11px;
margin-top: -11px;
border-right-width: 0;
border-left-color: #999;
border-left-color: rgba(0, 0, 0, .25);
}
.popover.left > .arrow:after {
right: 1px;
bottom: -10px;
content: " ";
border-right-width: 0;
border-left-color: #fff;
}
.carousel {
position: relative;
}
.carousel-inner {
position: relative;
width: 100%;
overflow: hidden;
}
.carousel-inner > .item {
position: relative;
display: none;
-webkit-transition: .6s ease-in-out left;
-o-transition: .6s ease-in-out left;
transition: .6s ease-in-out left;
}
.carousel-inner > .item > img,
.carousel-inner > .item > a > img {
line-height: 1;
}
.carousel-inner > .active,
.carousel-inner > .next,
.carousel-inner > .prev {
display: block;
}
.carousel-inner > .active {
left: 0;
}
.carousel-inner > .next,
.carousel-inner > .prev {
position: absolute;
top: 0;
width: 100%;
}
.carousel-inner > .next {
left: 100%;
}
.carousel-inner > .prev {
left: -100%;
}
.carousel-inner > .next.left,
.carousel-inner > .prev.right {
left: 0;
}
.carousel-inner > .active.left {
left: -100%;
}
.carousel-inner > .active.right {
left: 100%;
}
.carousel-control {
position: absolute;
top: 0;
bottom: 0;
left: 0;
width: 15%;
font-size: 20px;
color: #fff;
text-align: center;
text-shadow: 0 1px 2px rgba(0, 0, 0, .6);
filter: alpha(opacity=50);
opacity: .5;
}
.carousel-control.left {
background-image: -<API key>(left, rgba(0, 0, 0, .5) 0%, rgba(0, 0, 0, .0001) 100%);
background-image: -o-linear-gradient(left, rgba(0, 0, 0, .5) 0%, rgba(0, 0, 0, .0001) 100%);
background-image: -webkit-gradient(linear, left top, right top, from(rgba(0, 0, 0, .5)), to(rgba(0, 0, 0, .0001)));
background-image: linear-gradient(to right, rgba(0, 0, 0, .5) 0%, rgba(0, 0, 0, .0001) 100%);
filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#80000000', endColorstr='#00000000', GradientType=1);
background-repeat: repeat-x;
}
.carousel-control.right {
right: 0;
left: auto;
background-image: -<API key>(left, rgba(0, 0, 0, .0001) 0%, rgba(0, 0, 0, .5) 100%);
background-image: -o-linear-gradient(left, rgba(0, 0, 0, .0001) 0%, rgba(0, 0, 0, .5) 100%);
background-image: -webkit-gradient(linear, left top, right top, from(rgba(0, 0, 0, .0001)), to(rgba(0, 0, 0, .5)));
background-image: linear-gradient(to right, rgba(0, 0, 0, .0001) 0%, rgba(0, 0, 0, .5) 100%);
filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#00000000', endColorstr='#80000000', GradientType=1);
background-repeat: repeat-x;
}
.carousel-control:hover,
.carousel-control:focus {
color: #fff;
text-decoration: none;
filter: alpha(opacity=90);
outline: 0;
opacity: .9;
}
.carousel-control .icon-prev,
.carousel-control .icon-next,
.carousel-control .<API key>,
.carousel-control .<API key> {
position: absolute;
top: 50%;
z-index: 5;
display: inline-block;
}
.carousel-control .icon-prev,
.carousel-control .<API key> {
left: 50%;
margin-left: -10px;
}
.carousel-control .icon-next,
.carousel-control .<API key> {
right: 50%;
margin-right: -10px;
}
.carousel-control .icon-prev,
.carousel-control .icon-next {
width: 20px;
height: 20px;
margin-top: -10px;
font-family: serif;
}
.carousel-control .icon-prev:before {
content: '\2039';
}
.carousel-control .icon-next:before {
content: '\203a';
}
.carousel-indicators {
position: absolute;
bottom: 10px;
left: 50%;
z-index: 15;
width: 60%;
padding-left: 0;
margin-left: -30%;
text-align: center;
list-style: none;
}
.carousel-indicators li {
display: inline-block;
width: 10px;
height: 10px;
margin: 1px;
text-indent: -999px;
cursor: pointer;
background-color: #000 \9;
background-color: rgba(0, 0, 0, 0);
border: 1px solid #fff;
border-radius: 10px;
}
.carousel-indicators .active {
width: 12px;
height: 12px;
margin: 0;
background-color: #fff;
}
.carousel-caption {
position: absolute;
right: 15%;
bottom: 20px;
left: 15%;
z-index: 10;
padding-top: 20px;
padding-bottom: 20px;
color: #fff;
text-align: center;
text-shadow: 0 1px 2px rgba(0, 0, 0, .6);
}
.carousel-caption .btn {
text-shadow: none;
}
@media screen and (min-width: 768px) {
.carousel-control .<API key>,
.carousel-control .<API key>,
.carousel-control .icon-prev,
.carousel-control .icon-next {
width: 30px;
height: 30px;
margin-top: -15px;
font-size: 30px;
}
.carousel-control .<API key>,
.carousel-control .icon-prev {
margin-left: -15px;
}
.carousel-control .<API key>,
.carousel-control .icon-next {
margin-right: -15px;
}
.carousel-caption {
right: 20%;
left: 20%;
padding-bottom: 30px;
}
.carousel-indicators {
bottom: 20px;
}
}
.clearfix:before,
.clearfix:after,
.dl-horizontal dd:before,
.dl-horizontal dd:after,
.container:before,
.container:after,
.container-fluid:before,
.container-fluid:after,
.row:before,
.row:after,
.form-horizontal .form-group:before,
.form-horizontal .form-group:after,
.btn-toolbar:before,
.btn-toolbar:after,
.btn-group-vertical > .btn-group:before,
.btn-group-vertical > .btn-group:after,
.nav:before,
.nav:after,
.navbar:before,
.navbar:after,
.navbar-header:before,
.navbar-header:after,
.navbar-collapse:before,
.navbar-collapse:after,
.pager:before,
.pager:after,
.panel-body:before,
.panel-body:after,
.modal-footer:before,
.modal-footer:after {
display: table;
content: " ";
}
.clearfix:after,
.dl-horizontal dd:after,
.container:after,
.container-fluid:after,
.row:after,
.form-horizontal .form-group:after,
.btn-toolbar:after,
.btn-group-vertical > .btn-group:after,
.nav:after,
.navbar:after,
.navbar-header:after,
.navbar-collapse:after,
.pager:after,
.panel-body:after,
.modal-footer:after {
clear: both;
}
.center-block {
display: block;
margin-right: auto;
margin-left: auto;
}
.pull-right {
float: right !important;
}
.pull-left {
float: left !important;
}
.hide {
display: none !important;
}
.show {
display: block !important;
}
.invisible {
visibility: hidden;
}
.text-hide {
font: 0/0 a;
color: transparent;
text-shadow: none;
background-color: transparent;
border: 0;
}
.hidden {
display: none !important;
visibility: hidden !important;
}
.affix {
position: fixed;
-webkit-transform: translate3d(0, 0, 0);
-o-transform: translate3d(0, 0, 0);
transform: translate3d(0, 0, 0);
}
@-ms-viewport {
width: device-width;
}
.visible-xs,
.visible-sm,
.visible-md,
.visible-lg {
display: none !important;
}
.visible-xs-block,
.visible-xs-inline,
.<API key>,
.visible-sm-block,
.visible-sm-inline,
.<API key>,
.visible-md-block,
.visible-md-inline,
.<API key>,
.visible-lg-block,
.visible-lg-inline,
.<API key> {
display: none !important;
}
@media (max-width: 767px) {
.visible-xs {
display: block !important;
}
table.visible-xs {
display: table;
}
tr.visible-xs {
display: table-row !important;
}
th.visible-xs,
td.visible-xs {
display: table-cell !important;
}
}
@media (max-width: 767px) {
.visible-xs-block {
display: block !important;
}
}
@media (max-width: 767px) {
.visible-xs-inline {
display: inline !important;
}
}
@media (max-width: 767px) {
.<API key> {
display: inline-block !important;
}
}
@media (min-width: 768px) and (max-width: 991px) {
.visible-sm {
display: block !important;
}
table.visible-sm {
display: table;
}
tr.visible-sm {
display: table-row !important;
}
th.visible-sm,
td.visible-sm {
display: table-cell !important;
}
}
@media (min-width: 768px) and (max-width: 991px) {
.visible-sm-block {
display: block !important;
}
}
@media (min-width: 768px) and (max-width: 991px) {
.visible-sm-inline {
display: inline !important;
}
}
@media (min-width: 768px) and (max-width: 991px) {
.<API key> {
display: inline-block !important;
}
}
@media (min-width: 992px) and (max-width: 1199px) {
.visible-md {
display: block !important;
}
table.visible-md {
display: table;
}
tr.visible-md {
display: table-row !important;
}
th.visible-md,
td.visible-md {
display: table-cell !important;
}
}
@media (min-width: 992px) and (max-width: 1199px) {
.visible-md-block {
display: block !important;
}
}
@media (min-width: 992px) and (max-width: 1199px) {
.visible-md-inline {
display: inline !important;
}
}
@media (min-width: 992px) and (max-width: 1199px) {
.<API key> {
display: inline-block !important;
}
}
@media (min-width: 1200px) {
.visible-lg {
display: block !important;
}
table.visible-lg {
display: table;
}
tr.visible-lg {
display: table-row !important;
}
th.visible-lg,
td.visible-lg {
display: table-cell !important;
}
}
@media (min-width: 1200px) {
.visible-lg-block {
display: block !important;
}
}
@media (min-width: 1200px) {
.visible-lg-inline {
display: inline !important;
}
}
@media (min-width: 1200px) {
.<API key> {
display: inline-block !important;
}
}
@media (max-width: 767px) {
.hidden-xs {
display: none !important;
}
}
@media (min-width: 768px) and (max-width: 991px) {
.hidden-sm {
display: none !important;
}
}
@media (min-width: 992px) and (max-width: 1199px) {
.hidden-md {
display: none !important;
}
}
@media (min-width: 1200px) {
.hidden-lg {
display: none !important;
}
}
.visible-print {
display: none !important;
}
@media print {
.visible-print {
display: block !important;
}
table.visible-print {
display: table;
}
tr.visible-print {
display: table-row !important;
}
th.visible-print,
td.visible-print {
display: table-cell !important;
}
}
.visible-print-block {
display: none !important;
}
@media print {
.visible-print-block {
display: block !important;
}
}
.<API key> {
display: none !important;
}
@media print {
.<API key> {
display: inline !important;
}
}
.<API key> {
display: none !important;
}
@media print {
.<API key> {
display: inline-block !important;
}
}
@media print {
.hidden-print {
display: none !important;
}
}
/*# sourceMappingURL=bootstrap.css.map */
|
#!/usr/bin/env python
import os, sys, traceback
import Ice, AllTests
def test(b):
if not b:
raise RuntimeError('test assertion failed')
def usage(n):
sys.stderr.write("Usage: " + n + " port...\n")
def run(args, communicator):
ports = []
for arg in args[1:]:
if arg[0] == '-':
sys.stderr.write(args[0] + ": unknown option `" + arg + "'\n")
usage(args[0])
return False
ports.append(int(arg))
if len(ports) == 0:
sys.stderr.write(args[0] + ": no ports specified\n")
usage(args[0])
return False
try:
AllTests.allTests(communicator, ports)
except:
traceback.print_exc()
test(False)
return True
try:
initData = Ice.InitializationData()
initData.properties = Ice.createProperties(sys.argv)
# This test aborts servers, so we don't want warnings.
initData.properties.setProperty('Ice.Warn.Connections', '0')
communicator = Ice.initialize(sys.argv, initData)
status = run(sys.argv, communicator)
except:
traceback.print_exc()
status = False
if communicator:
try:
communicator.destroy()
except:
traceback.print_exc()
status = False
sys.exit(not status)
|
#include <unistd.h>
#include <tqcstring.h>
#include <tqcursor.h>
#include <tqdatastream.h>
#include <tqdir.h>
#include <tqdragobject.h>
#include <tqfileinfo.h>
#include <tqheader.h>
#include <tqpainter.h>
#include <tqpopupmenu.h>
#include <tqregexp.h>
#include <tqstringlist.h>
#include <tdeglobal.h>
#include <kstandarddirs.h>
#include <kinputdialog.h>
#include <tdelocale.h>
#include <ksimpleconfig.h>
#include <kdebug.h>
#include <kiconloader.h>
#include <kdesktopfile.h>
#include <tdeaction.h>
#include <tdemessagebox.h>
#include <tdeapplication.h>
#include <kservice.h>
#include <kservicegroup.h>
#include <tdemultipledrag.h>
#include <kurldrag.h>
#include "treeview.h"
#include "treeview.moc"
#include "khotkeys.h"
#include "menufile.h"
#include "menuinfo.h"
#define MOVE_FOLDER 'M'
#define COPY_FOLDER 'C'
#define MOVE_FILE 'm'
#define COPY_FILE 'c'
#define COPY_SEPARATOR 'S'
TreeItem::TreeItem(TQListViewItem *parent, TQListViewItem *after, const TQString& menuId, bool __init)
:TQListViewItem(parent, after), _hidden(false), _init(__init), _layoutDirty(false), _menuId(menuId),
m_folderInfo(0), m_entryInfo(0) {}
TreeItem::TreeItem(TQListView *parent, TQListViewItem *after, const TQString& menuId, bool __init)
: TQListViewItem(parent, after), _hidden(false), _init(__init), _layoutDirty(false), _menuId(menuId),
m_folderInfo(0), m_entryInfo(0) {}
void TreeItem::setName(const TQString &name)
{
_name = name;
update();
}
void TreeItem::setHidden(bool b)
{
if (_hidden == b) return;
_hidden = b;
update();
}
void TreeItem::update()
{
TQString s = _name;
if (_hidden)
s += i18n(" [Hidden]");
setText(0, s);
}
void TreeItem::setOpen(bool o)
{
if (o)
load();
TQListViewItem::setOpen(o);
}
void TreeItem::load()
{
if (m_folderInfo && !_init)
{
_init = true;
TreeView *tv = static_cast<TreeView *>(listView());
tv->fillBranch(m_folderInfo, this);
}
}
void TreeItem::paintCell ( TQPainter * p, const TQColorGroup & cg, int column, int width, int align )
{
TQListViewItem::paintCell(p, cg, column, width, align);
if (!m_folderInfo && !m_entryInfo)
{
// Draw Separator
int h = (height() / 2) -1;
if (isSelected())
p->setPen( cg.highlightedText() );
else
p->setPen( cg.text() );
p->drawLine(0, h,
width, h);
}
}
void TreeItem::setup()
{
TQListViewItem::setup();
if (!m_folderInfo && !m_entryInfo)
setHeight(8);
}
static TQPixmap appIcon(const TQString &iconName)
{
TQPixmap normal = TDEGlobal::iconLoader()->loadIcon(iconName, TDEIcon::Small, 0, TDEIcon::DefaultState, 0L, true);
// make sure they are not larger than 20x20
if (normal.width() > 20 || normal.height() > 20)
{
TQImage tmp = normal.convertToImage();
tmp = tmp.smoothScale(20, 20);
normal.convertFromImage(tmp);
}
return normal;
}
TreeView::TreeView( bool controlCenter, TDEActionCollection *ac, TQWidget *parent, const char *name )
: TDEListView(parent, name), m_ac(ac), m_rmb(0), m_clipboard(0),
<API key>(0), <API key>(0),
m_controlCenter(controlCenter), m_layoutDirty(false)
{
setFrameStyle(TQFrame::WinPanel | TQFrame::Sunken);
<API key>(true);
setRootIsDecorated(true);
setSorting(-1);
setAcceptDrops(true);
setDropVisualizer(true);
setDragEnabled(true);
setMinimumWidth(240);
addColumn("");
header()->hide();
connect(this, TQT_SIGNAL(dropped(TQDropEvent*, TQListViewItem*, TQListViewItem*)),
TQT_SLOT(slotDropped(TQDropEvent*, TQListViewItem*, TQListViewItem*)));
connect(this, TQT_SIGNAL(clicked( TQListViewItem* )),
TQT_SLOT(itemSelected( TQListViewItem* )));
connect(this,TQT_SIGNAL(selectionChanged ( TQListViewItem * )),
TQT_SLOT(itemSelected( TQListViewItem* )));
connect(this, TQT_SIGNAL(rightButtonPressed(TQListViewItem*, const TQPoint&, int)),
TQT_SLOT(slotRMBPressed(TQListViewItem*, const TQPoint&)));
// connect actions
connect(m_ac->action("newitem"), TQT_SIGNAL(activated()), TQT_SLOT(newitem()));
connect(m_ac->action("newsubmenu"), TQT_SIGNAL(activated()), TQT_SLOT(newsubmenu()));
if (m_ac->action("newsep"))
connect(m_ac->action("newsep"), TQT_SIGNAL(activated()), TQT_SLOT(newsep()));
m_menuFile = new MenuFile( locateLocal("xdgconf-menu", "<API key>.menu"));
m_rootFolder = new MenuFolderInfo;
m_separator = new MenuSeparatorInfo;
m_drag = 0;
// Read menu format configuration information
TDESharedConfig::Ptr pConfig = TDESharedConfig::openConfig("kickerrc");
pConfig->setGroup("menus");
<API key> = pConfig->readBoolEntry("DetailedMenuEntries",true);
if (<API key>)
{
<API key> = pConfig->readBoolEntry("<API key>",false);
}
}
TreeView::~TreeView() {
cleanupClipboard();
delete m_rootFolder;
delete m_separator;
}
void TreeView::setViewMode(bool showHidden)
{
delete m_rmb;
// setup rmb menu
m_rmb = new TQPopupMenu(this);
TDEAction *action;
action = m_ac->action("edit_cut");
if(action) {
action->plug(m_rmb);
action->setEnabled(false);
connect(action, TQT_SIGNAL(activated()), TQT_SLOT(cut()));
}
action = m_ac->action("edit_copy");
if(action) {
action->plug(m_rmb);
action->setEnabled(false);
connect(action, TQT_SIGNAL(activated()), TQT_SLOT(copy()));
}
action = m_ac->action("edit_paste");
if(action) {
action->plug(m_rmb);
action->setEnabled(false);
connect(action, TQT_SIGNAL(activated()), TQT_SLOT(paste()));
}
m_rmb->insertSeparator();
action = m_ac->action("delete");
if(action) {
action->plug(m_rmb);
action->setEnabled(false);
connect(action, TQT_SIGNAL(activated()), TQT_SLOT(del()));
}
m_rmb->insertSeparator();
if(m_ac->action("newitem"))
m_ac->action("newitem")->plug(m_rmb);
if(m_ac->action("newsubmenu"))
m_ac->action("newsubmenu")->plug(m_rmb);
if(m_ac->action("newsep"))
m_ac->action("newsep")->plug(m_rmb);
m_showHidden = showHidden;
readMenuFolderInfo();
fill();
}
void TreeView::readMenuFolderInfo(MenuFolderInfo *folderInfo, KServiceGroup::Ptr folder, const TQString &prefix)
{
if (!folderInfo)
{
folderInfo = m_rootFolder;
if (m_controlCenter)
folder = KServiceGroup::baseGroup("settings");
else
folder = KServiceGroup::root();
}
if (!folder || !folder->isValid())
return;
folderInfo->caption = folder->caption();
folderInfo->comment = folder->comment();
// Item names may contain ampersands. To avoid them being converted
// to accelerators, replace them with two ampersands.
folderInfo->hidden = folder->noDisplay();
folderInfo->directoryFile = folder->directoryEntryPath();
folderInfo->icon = folder->icon();
TQString id = folder->relPath();
int i = id.findRev('/', -2);
id = id.mid(i+1);
folderInfo->id = id;
folderInfo->fullId = prefix + id;
KServiceGroup::List list = folder->entries(true, !m_showHidden, true, <API key> && !<API key>);
for(KServiceGroup::List::ConstIterator it = list.begin();
it != list.end(); ++it)
{
KSycocaEntry * e = *it;
if (e->isType(KST_KServiceGroup))
{
KServiceGroup::Ptr g(static_cast<KServiceGroup *>(e));
MenuFolderInfo *subFolderInfo = new MenuFolderInfo();
readMenuFolderInfo(subFolderInfo, g, folderInfo->fullId);
folderInfo->add(subFolderInfo, true);
}
else if (e->isType(KST_KService))
{
folderInfo->add(new MenuEntryInfo(static_cast<KService *>(e)), true);
}
else if (e->isType(<API key>))
{
folderInfo->add(m_separator, true);
}
}
}
void TreeView::fill()
{
TQApplication::setOverrideCursor(Qt::WaitCursor);
clear();
fillBranch(m_rootFolder, 0);
TQApplication::<API key>();
}
TQString TreeView::findName(KDesktopFile *df, bool deleted)
{
TQString name = df->readName();
if (deleted)
{
if (name == "empty")
name = TQString::null;
if (name.isEmpty())
{
TQString file = df->fileName();
TQString res = df->resource();
bool isLocal = true;
TQStringList files = TDEGlobal::dirs()->findAllResources(res.latin1(), file);
for(TQStringList::ConstIterator it = files.begin();
it != files.end();
++it)
{
if (isLocal)
{
isLocal = false;
continue;
}
KDesktopFile df2(*it);
name = df2.readName();
if (!name.isEmpty() && (name != "empty"))
return name;
}
}
}
return name;
}
TreeItem *TreeView::createTreeItem(TreeItem *parent, TQListViewItem *after, MenuFolderInfo *folderInfo, bool _init)
{
TreeItem *item;
if (parent == 0)
item = new TreeItem(this, after, TQString::null, _init);
else
item = new TreeItem(parent, after, TQString::null, _init);
item->setMenuFolderInfo(folderInfo);
item->setName(folderInfo->caption);
item->setPixmap(0, appIcon(folderInfo->icon));
item->setDirectoryPath(folderInfo->fullId);
item->setHidden(folderInfo->hidden);
item->setExpandable(true);
return item;
}
TreeItem *TreeView::createTreeItem(TreeItem *parent, TQListViewItem *after, MenuEntryInfo *entryInfo, bool _init)
{
bool hidden = entryInfo->hidden;
TreeItem* item;
if (parent == 0)
item = new TreeItem(this, after, entryInfo->menuId(), _init);
else
item = new TreeItem(parent, after, entryInfo->menuId(),_init);
QString name;
if (<API key> && entryInfo->description.length() != 0)
{
if (<API key>)
{
name = entryInfo->caption + " (" + entryInfo->description + ")";
}
else
{
name = entryInfo->description + " (" + entryInfo->caption + ")";
}
}
else
{
name = entryInfo->caption;
}
item->setMenuEntryInfo(entryInfo);
item->setName(name);
item->setPixmap(0, appIcon(entryInfo->icon));
item->setHidden(hidden);
return item;
}
TreeItem *TreeView::createTreeItem(TreeItem *parent, TQListViewItem *after, MenuSeparatorInfo *, bool _init)
{
TreeItem* item;
if (parent == 0)
item = new TreeItem(this, after, TQString::null, _init);
else
item = new TreeItem(parent, after, TQString::null,_init);
return item;
}
void TreeView::fillBranch(MenuFolderInfo *folderInfo, TreeItem *parent)
{
TQString relPath = parent ? parent->directory() : TQString::null;
TQPtrListIterator<MenuInfo> it( folderInfo->initialLayout );
TreeItem *after = 0;
for (MenuInfo *info; (info = it.current()); ++it)
{
MenuEntryInfo *entry = dynamic_cast<MenuEntryInfo*>(info);
if (entry)
{
after = createTreeItem(parent, after, entry);
continue;
}
MenuFolderInfo *subFolder = dynamic_cast<MenuFolderInfo*>(info);
if (subFolder)
{
after = createTreeItem(parent, after, subFolder);
continue;
}
MenuSeparatorInfo *separator = dynamic_cast<MenuSeparatorInfo*>(info);
if (separator)
{
after = createTreeItem(parent, after, separator);
continue;
}
}
}
void TreeView::closeAllItems(TQListViewItem *item)
{
if (!item) return;
while(item)
{
item->setOpen(false);
closeAllItems(item->firstChild());
item = item->nextSibling();
}
}
void TreeView::selectMenu(const TQString &menu)
{
closeAllItems(firstChild());
if (menu.length() <= 1)
{
setCurrentItem(firstChild());
clearSelection();
return; // Root menu
}
TQString restMenu = menu.mid(1);
if (!restMenu.endsWith("/"))
restMenu += "/";
TreeItem *item = 0;
do
{
int i = restMenu.find("/");
TQString subMenu = restMenu.left(i+1);
restMenu = restMenu.mid(i+1);
item = (TreeItem*)(item ? item->firstChild() : firstChild());
while(item)
{
MenuFolderInfo *folderInfo = item->folderInfo();
if (folderInfo && (folderInfo->id == subMenu))
{
item->setOpen(true);
break;
}
item = (TreeItem*) item->nextSibling();
}
}
while( item && !restMenu.isEmpty());
if (item)
{
setCurrentItem(item);
ensureItemVisible(item);
}
}
void TreeView::selectMenuEntry(const TQString &menuEntry)
{
TreeItem *item = (TreeItem *) selectedItem();
if (!item)
{
item = (TreeItem *) currentItem();
while (item && item->isDirectory())
item = (TreeItem*) item->nextSibling();
}
else
item = (TreeItem *) item->firstChild();
while(item)
{
MenuEntryInfo *entry = item->entryInfo();
if (entry && (entry->menuId() == menuEntry))
{
setCurrentItem(item);
ensureItemVisible(item);
return;
}
item = (TreeItem*) item->nextSibling();
}
}
void TreeView::itemSelected(TQListViewItem *item)
{
TreeItem *_item = (TreeItem*)item;
bool selected = false;
bool dselected = false;
if (_item) {
selected = true;
dselected = _item->isHidden();
}
m_ac->action("edit_cut")->setEnabled(selected);
m_ac->action("edit_copy")->setEnabled(selected);
if (m_ac->action("delete"))
m_ac->action("delete")->setEnabled(selected && !dselected);
if(!item)
{
emit disableAction();
return;
}
if (_item->isDirectory())
emit entrySelected(_item->folderInfo());
else
emit entrySelected(_item->entryInfo());
}
void TreeView::currentChanged(MenuFolderInfo *folderInfo)
{
TreeItem *item = (TreeItem*)selectedItem();
if (item == 0) return;
if (folderInfo == 0) return;
item->setName(folderInfo->caption);
item->setPixmap(0, appIcon(folderInfo->icon));
}
void TreeView::currentChanged(MenuEntryInfo *entryInfo)
{
TreeItem *item = (TreeItem*)selectedItem();
if (item == 0) return;
if (entryInfo == 0) return;
QString name;
if (<API key> && entryInfo->description.length() != 0)
{
if (<API key>)
{
name = entryInfo->caption + " (" + entryInfo->description + ")";
}
else
{
name = entryInfo->description + " (" + entryInfo->caption + ")";
}
}
else
{
name = entryInfo->caption;
}
item->setName(name);
item->setPixmap(0, appIcon(entryInfo->icon));
}
TQStringList TreeView::fileList(const TQString& rPath)
{
TQString relativePath = rPath;
// truncate "/.directory"
int pos = relativePath.findRev("/.directory");
if (pos > 0) relativePath.truncate(pos);
TQStringList filelist;
// loop through all resource dirs and build a file list
TQStringList resdirlist = TDEGlobal::dirs()->resourceDirs("apps");
for (TQStringList::ConstIterator it = resdirlist.begin(); it != resdirlist.end(); ++it)
{
TQDir dir((*it) + "/" + relativePath);
if(!dir.exists()) continue;
dir.setFilter(TQDir::Files);
dir.setNameFilter("*.desktop;*.kdelnk");
// build a list of files
TQStringList files = dir.entryList();
for (TQStringList::ConstIterator it = files.begin(); it != files.end(); ++it) {
// does not work?!
//if (filelist.contains(*it)) continue;
if (relativePath.isEmpty()) {
filelist.remove(*it); // hack
filelist.append(*it);
}
else {
filelist.remove(relativePath + "/" + *it); //hack
filelist.append(relativePath + "/" + *it);
}
}
}
return filelist;
}
TQStringList TreeView::dirList(const TQString& rPath)
{
TQString relativePath = rPath;
// truncate "/.directory"
int pos = relativePath.findRev("/.directory");
if (pos > 0) relativePath.truncate(pos);
TQStringList dirlist;
// loop through all resource dirs and build a subdir list
TQStringList resdirlist = TDEGlobal::dirs()->resourceDirs("apps");
for (TQStringList::ConstIterator it = resdirlist.begin(); it != resdirlist.end(); ++it)
{
TQDir dir((*it) + "/" + relativePath);
if(!dir.exists()) continue;
dir.setFilter(TQDir::Dirs);
// build a list of subdirs
TQStringList subdirs = dir.entryList();
for (TQStringList::ConstIterator it = subdirs.begin(); it != subdirs.end(); ++it) {
if ((*it) == "." || (*it) == "..") continue;
// does not work?!
// if (dirlist.contains(*it)) continue;
if (relativePath.isEmpty()) {
dirlist.remove(*it); //hack
dirlist.append(*it);
}
else {
dirlist.remove(relativePath + "/" + *it); //hack
dirlist.append(relativePath + "/" + *it);
}
}
}
return dirlist;
}
bool TreeView::acceptDrag(TQDropEvent* e) const
{
if (e->provides("application/<API key>") &&
(e->source() == const_cast<TreeView *>(this)))
return true;
KURL::List urls;
if (KURLDrag::decode(e, urls) && (urls.count() == 1) &&
urls[0].isLocalFile() && urls[0].path().endsWith(".desktop"))
return true;
return false;
}
static TQString createDesktopFile(const TQString &file, TQString *menuId, TQStringList *excludeList)
{
TQString base = file.mid(file.findRev('/')+1);
base = base.left(base.findRev('.'));
TQRegExp r("(.*)(?=-\\d+)");
base = (r.search(base) > -1) ? r.cap(1) : base;
TQString result = KService::newServicePath(true, base, menuId, excludeList);
excludeList->append(*menuId);
// Todo for Undo-support: Undo menuId allocation:
return result;
}
static KDesktopFile *copyDesktopFile(MenuEntryInfo *entryInfo, TQString *menuId, TQStringList *excludeList)
{
TQString result = createDesktopFile(entryInfo->file(), menuId, excludeList);
KDesktopFile *df = entryInfo->desktopFile()->copyTo(result);
df->deleteEntry("Categories"); // Don't set any categories!
return df;
}
static TQString createDirectoryFile(const TQString &file, TQStringList *excludeList)
{
TQString base = file.mid(file.findRev('/')+1);
base = base.left(base.findRev('.'));
TQString result;
int i = 1;
while(true)
{
if (i == 1)
result = base + ".directory";
else
result = base + TQString("-%1.directory").arg(i);
if (!excludeList->contains(result))
{
if (locate("xdgdata-dirs", result).isEmpty())
break;
}
i++;
}
excludeList->append(result);
result = locateLocal("xdgdata-dirs", result);
return result;
}
void TreeView::slotDropped (TQDropEvent * e, TQListViewItem *parent, TQListViewItem*after)
{
if(!e) return;
// get destination folder
TreeItem *parentItem = static_cast<TreeItem*>(parent);
TQString folder = parentItem ? parentItem->directory() : TQString::null;
MenuFolderInfo *parentFolderInfo = parentItem ? parentItem->folderInfo() : m_rootFolder;
if (e->source() != this)
{
// External drop
KURL::List urls;
if (!KURLDrag::decode(e, urls) || (urls.count() != 1) || !urls[0].isLocalFile())
return;
TQString path = urls[0].path();
if (!path.endsWith(".desktop"))
return;
TQString menuId;
TQString result = createDesktopFile(path, &menuId, &m_newMenuIds);
KDesktopFile orig_df(path);
KDesktopFile *df = orig_df.copyTo(result);
df->deleteEntry("Categories"); // Don't set any categories!
KService *s = new KService(df);
s->setMenuId(menuId);
MenuEntryInfo *entryInfo = new MenuEntryInfo(s, df);
TQString oldCaption = entryInfo->caption;
TQString newCaption = parentFolderInfo->uniqueItemCaption(oldCaption, oldCaption);
entryInfo->setCaption(newCaption);
// Add file to menu
// m_menuFile->addEntry(folder, menuId);
m_menuFile->pushAction(MenuFile::ADD_ENTRY, folder, menuId);
// create the TreeItem
if(parentItem)
parentItem->setOpen(true);
// update fileInfo data
parentFolderInfo->add(entryInfo);
TreeItem *newItem = createTreeItem(parentItem, after, entryInfo, true);
setSelected ( newItem, true);
itemSelected( newItem);
m_drag = 0;
setLayoutDirty(parentItem);
return;
}
// is there content in the clipboard?
if (!m_drag) return;
if (m_dragItem == after) return; // Nothing to do
int command = m_drag;
if (command == MOVE_FOLDER)
{
MenuFolderInfo *folderInfo = m_dragInfo;
if (e->action() == TQDropEvent::Copy)
{
// Ugh.. this is hard :)
// * Create new .directory file
// Add
}
else
{
TreeItem *tmpItem = static_cast<TreeItem*>(parentItem);
while ( tmpItem )
{
if ( tmpItem == m_dragItem )
{
m_drag = 0;
return;
}
tmpItem = static_cast<TreeItem*>(tmpItem->parent() );
}
// Remove MenuFolderInfo
TreeItem *oldParentItem = static_cast<TreeItem*>(m_dragItem->parent());
MenuFolderInfo *oldParentFolderInfo = oldParentItem ? oldParentItem->folderInfo() : m_rootFolder;
oldParentFolderInfo->take(folderInfo);
// Move menu
TQString oldFolder = folderInfo->fullId;
TQString folderName = folderInfo->id;
TQString newFolder = m_menuFile->uniqueMenuName(folder, folderName, parentFolderInfo->existingMenuIds());
folderInfo->id = newFolder;
// Add file to menu
//m_menuFile->moveMenu(oldFolder, folder + newFolder);
m_menuFile->pushAction(MenuFile::MOVE_MENU, oldFolder, folder + newFolder);
// Make sure caption is unique
TQString newCaption = parentFolderInfo->uniqueMenuCaption(folderInfo->caption);
if (newCaption != folderInfo->caption)
{
folderInfo->setCaption(newCaption);
}
// create the TreeItem
if(parentItem)
parentItem->setOpen(true);
// update fileInfo data
folderInfo->updateFullId(parentFolderInfo->fullId);
folderInfo->setInUse(true);
parentFolderInfo->add(folderInfo);
if ((parentItem != oldParentItem) || !after)
{
if (oldParentItem)
oldParentItem->takeItem(m_dragItem);
else
takeItem(m_dragItem);
if (parentItem)
parentItem->insertItem(m_dragItem);
else
insertItem(m_dragItem);
}
m_dragItem->moveItem(after);
m_dragItem->setName(folderInfo->caption);
m_dragItem->setDirectoryPath(folderInfo->fullId);
setSelected(m_dragItem, true);
itemSelected(m_dragItem);
}
}
else if (command == MOVE_FILE)
{
MenuEntryInfo *entryInfo = m_dragItem->entryInfo();
TQString menuId = entryInfo->menuId();
if (e->action() == TQDropEvent::Copy)
{
// Need to copy file and then add it
KDesktopFile *df = copyDesktopFile(entryInfo, &menuId, &m_newMenuIds); // Duplicate
//UNDO-ACTION: NEW_MENU_ID (menuId)
KService *s = new KService(df);
s->setMenuId(menuId);
entryInfo = new MenuEntryInfo(s, df);
TQString oldCaption = entryInfo->caption;
TQString newCaption = parentFolderInfo->uniqueItemCaption(oldCaption, oldCaption);
entryInfo->setCaption(newCaption);
}
else
{
del(m_dragItem, false);
TQString oldCaption = entryInfo->caption;
TQString newCaption = parentFolderInfo->uniqueItemCaption(oldCaption);
entryInfo->setCaption(newCaption);
entryInfo->setInUse(true);
}
// Add file to menu
// m_menuFile->addEntry(folder, menuId);
m_menuFile->pushAction(MenuFile::ADD_ENTRY, folder, menuId);
// create the TreeItem
if(parentItem)
parentItem->setOpen(true);
// update fileInfo data
parentFolderInfo->add(entryInfo);
TreeItem *newItem = createTreeItem(parentItem, after, entryInfo, true);
setSelected ( newItem, true);
itemSelected( newItem);
}
else if (command == COPY_SEPARATOR)
{
if (e->action() != TQDropEvent::Copy)
del(m_dragItem, false);
TreeItem *newItem = createTreeItem(parentItem, after, m_separator, true);
setSelected ( newItem, true);
itemSelected( newItem);
}
else
{
// Error
}
m_drag = 0;
setLayoutDirty(parentItem);
}
void TreeView::startDrag()
{
TQDragObject *drag = dragObject();
if (!drag)
return;
drag->dragMove();
}
TQDragObject *TreeView::dragObject()
{
m_dragPath = TQString::null;
TreeItem *item = (TreeItem*)selectedItem();
if(item == 0) return 0;
KMultipleDrag *drag = new KMultipleDrag( this );
if (item->isDirectory())
{
m_drag = MOVE_FOLDER;
m_dragInfo = item->folderInfo();
m_dragItem = item;
}
else if (item->isEntry())
{
m_drag = MOVE_FILE;
m_dragInfo = 0;
m_dragItem = item;
TQString menuId = item->menuId();
m_dragPath = item->entryInfo()->service->desktopEntryPath();
if (!m_dragPath.isEmpty())
m_dragPath = locate("apps", m_dragPath);
if (!m_dragPath.isEmpty())
{
KURL url;
url.setPath(m_dragPath);
drag->addDragObject( new KURLDrag(url, 0));
}
}
else
{
m_drag = COPY_SEPARATOR;
m_dragInfo = 0;
m_dragItem = item;
}
drag->addDragObject( new TQStoredDrag("application/<API key>", 0));
if ( item->pixmap(0) )
drag->setPixmap(*item->pixmap(0));
return drag;
}
void TreeView::slotRMBPressed(TQListViewItem*, const TQPoint& p)
{
TreeItem *item = (TreeItem*)selectedItem();
if(item == 0) return;
if(m_rmb) m_rmb->exec(p);
}
void TreeView::newsubmenu()
{
TreeItem *parentItem = 0;
TreeItem *item = (TreeItem*)selectedItem();
bool ok;
TQString caption = KInputDialog::getText( i18n( "New Submenu" ),
i18n( "Submenu name:" ), TQString::null, &ok, this );
if (!ok) return;
TQString file = caption;
file.replace('/', '-');
file = createDirectoryFile(file, &m_newDirectoryList); // Create
// get destination folder
TQString folder;
if(!item)
{
parentItem = 0;
folder = TQString::null;
}
else if(item->isDirectory())
{
parentItem = item;
item = 0;
folder = parentItem->directory();
}
else
{
parentItem = static_cast<TreeItem*>(item->parent());
folder = parentItem ? parentItem->directory() : TQString::null;
}
MenuFolderInfo *parentFolderInfo = parentItem ? parentItem->folderInfo() : m_rootFolder;
MenuFolderInfo *folderInfo = new MenuFolderInfo();
folderInfo->caption = parentFolderInfo->uniqueMenuCaption(caption);
folderInfo->id = m_menuFile->uniqueMenuName(folder, caption, parentFolderInfo->existingMenuIds());
folderInfo->directoryFile = file;
folderInfo->icon = "package";
folderInfo->hidden = false;
folderInfo->setDirty();
KDesktopFile *df = new KDesktopFile(file);
df->writeEntry("Name", folderInfo->caption);
df->writeEntry("Icon", folderInfo->icon);
df->sync();
delete df;
// Add file to menu
// m_menuFile->addMenu(folder + folderInfo->id, file);
m_menuFile->pushAction(MenuFile::ADD_MENU, folder + folderInfo->id, file);
folderInfo->fullId = parentFolderInfo->fullId + folderInfo->id;
// create the TreeItem
if(parentItem)
parentItem->setOpen(true);
// update fileInfo data
parentFolderInfo->add(folderInfo);
TreeItem *newItem = createTreeItem(parentItem, item, folderInfo, true);
setSelected ( newItem, true);
itemSelected( newItem);
setLayoutDirty(parentItem);
}
void TreeView::newitem()
{
TreeItem *parentItem = 0;
TreeItem *item = (TreeItem*)selectedItem();
bool ok;
TQString caption = KInputDialog::getText( i18n( "New Item" ),
i18n( "Item name:" ), TQString::null, &ok, this );
if (!ok) return;
TQString menuId;
TQString file = caption;
file.replace('/', '-');
file = createDesktopFile(file, &menuId, &m_newMenuIds); // Create
KDesktopFile *df = new KDesktopFile(file);
df->writeEntry("Name", caption);
df->writeEntry("Type", "Application");
// get destination folder
TQString folder;
if(!item)
{
parentItem = 0;
folder = TQString::null;
}
else if(item->isDirectory())
{
parentItem = item;
item = 0;
folder = parentItem->directory();
}
else
{
parentItem = static_cast<TreeItem*>(item->parent());
folder = parentItem ? parentItem->directory() : TQString::null;
}
MenuFolderInfo *parentFolderInfo = parentItem ? parentItem->folderInfo() : m_rootFolder;
// Add file to menu
// m_menuFile->addEntry(folder, menuId);
m_menuFile->pushAction(MenuFile::ADD_ENTRY, folder, menuId);
KService *s = new KService(df);
s->setMenuId(menuId);
MenuEntryInfo *entryInfo = new MenuEntryInfo(s, df);
// create the TreeItem
if(parentItem)
parentItem->setOpen(true);
// update fileInfo data
parentFolderInfo->add(entryInfo);
TreeItem *newItem = createTreeItem(parentItem, item, entryInfo, true);
setSelected ( newItem, true);
itemSelected( newItem);
setLayoutDirty(parentItem);
}
void TreeView::newsep()
{
TreeItem *parentItem = 0;
TreeItem *item = (TreeItem*)selectedItem();
if(!item)
{
parentItem = 0;
}
else if(item->isDirectory())
{
parentItem = item;
item = 0;
}
else
{
parentItem = static_cast<TreeItem*>(item->parent());
}
// create the TreeItem
if(parentItem)
parentItem->setOpen(true);
TreeItem *newItem = createTreeItem(parentItem, item, m_separator, true);
setSelected ( newItem, true);
itemSelected( newItem);
setLayoutDirty(parentItem);
}
void TreeView::cut()
{
copy( true );
m_ac->action("edit_cut")->setEnabled(false);
m_ac->action("edit_copy")->setEnabled(false);
m_ac->action("delete")->setEnabled(false);
// Select new current item
setSelected( currentItem(), true );
// Switch the UI to show that item
itemSelected( selectedItem() );
}
void TreeView::copy()
{
copy( false );
}
void TreeView::copy( bool cutting )
{
TreeItem *item = (TreeItem*)selectedItem();
// nil selected? -> nil to copy
if (item == 0) return;
if (cutting)
setLayoutDirty((TreeItem*)item->parent());
// clean up old stuff
cleanupClipboard();
// is item a folder or a file?
if(item->isDirectory())
{
TQString folder = item->directory();
if (cutting)
{
// Place in clipboard
m_clipboard = MOVE_FOLDER;
<API key> = item->folderInfo();
del(item, false);
}
else
{
// Place in clipboard
m_clipboard = COPY_FOLDER;
<API key> = item->folderInfo();
}
}
else if (item->isEntry())
{
if (cutting)
{
// Place in clipboard
m_clipboard = MOVE_FILE;
<API key> = item->entryInfo();
del(item, false);
}
else
{
// Place in clipboard
m_clipboard = COPY_FILE;
<API key> = item->entryInfo();
}
}
else
{
// Place in clipboard
m_clipboard = COPY_SEPARATOR;
if (cutting)
del(item, false);
}
m_ac->action("edit_paste")->setEnabled(true);
}
void TreeView::paste()
{
TreeItem *parentItem = 0;
TreeItem *item = (TreeItem*)selectedItem();
// nil selected? -> nil to paste to
if (item == 0) return;
// is there content in the clipboard?
if (!m_clipboard) return;
// get destination folder
TQString folder;
if(item->isDirectory())
{
parentItem = item;
item = 0;
folder = parentItem->directory();
}
else
{
parentItem = static_cast<TreeItem*>(item->parent());
folder = parentItem ? parentItem->directory() : TQString::null;
}
MenuFolderInfo *parentFolderInfo = parentItem ? parentItem->folderInfo() : m_rootFolder;
int command = m_clipboard;
if ((command == COPY_FOLDER) || (command == MOVE_FOLDER))
{
MenuFolderInfo *folderInfo = <API key>;
if (command == COPY_FOLDER)
{
// Ugh.. this is hard :)
// * Create new .directory file
// Add
}
else if (command == MOVE_FOLDER)
{
// Move menu
TQString oldFolder = folderInfo->fullId;
TQString folderName = folderInfo->id;
TQString newFolder = m_menuFile->uniqueMenuName(folder, folderName, parentFolderInfo->existingMenuIds());
folderInfo->id = newFolder;
// Add file to menu
// m_menuFile->moveMenu(oldFolder, folder + newFolder);
m_menuFile->pushAction(MenuFile::MOVE_MENU, oldFolder, folder + newFolder);
// Make sure caption is unique
TQString newCaption = parentFolderInfo->uniqueMenuCaption(folderInfo->caption);
if (newCaption != folderInfo->caption)
{
folderInfo->setCaption(newCaption);
}
// create the TreeItem
if(parentItem)
parentItem->setOpen(true);
// update fileInfo data
folderInfo->fullId = parentFolderInfo->fullId + folderInfo->id;
folderInfo->setInUse(true);
parentFolderInfo->add(folderInfo);
TreeItem *newItem = createTreeItem(parentItem, item, folderInfo);
setSelected ( newItem, true);
itemSelected( newItem);
}
m_clipboard = COPY_FOLDER; // Next one copies.
}
else if ((command == COPY_FILE) || (command == MOVE_FILE))
{
MenuEntryInfo *entryInfo = <API key>;
TQString menuId;
if (command == COPY_FILE)
{
// Need to copy file and then add it
KDesktopFile *df = copyDesktopFile(entryInfo, &menuId, &m_newMenuIds); // Duplicate
KService *s = new KService(df);
s->setMenuId(menuId);
entryInfo = new MenuEntryInfo(s, df);
TQString oldCaption = entryInfo->caption;
TQString newCaption = parentFolderInfo->uniqueItemCaption(oldCaption, oldCaption);
entryInfo->setCaption(newCaption);
}
else if (command == MOVE_FILE)
{
menuId = entryInfo->menuId();
m_clipboard = COPY_FILE; // Next one copies.
TQString oldCaption = entryInfo->caption;
TQString newCaption = parentFolderInfo->uniqueItemCaption(oldCaption);
entryInfo->setCaption(newCaption);
entryInfo->setInUse(true);
}
// Add file to menu
// m_menuFile->addEntry(folder, menuId);
m_menuFile->pushAction(MenuFile::ADD_ENTRY, folder, menuId);
// create the TreeItem
if(parentItem)
parentItem->setOpen(true);
// update fileInfo data
parentFolderInfo->add(entryInfo);
TreeItem *newItem = createTreeItem(parentItem, item, entryInfo, true);
setSelected ( newItem, true);
itemSelected( newItem);
}
else
{
// create separator
if(parentItem)
parentItem->setOpen(true);
TreeItem *newItem = createTreeItem(parentItem, item, m_separator, true);
setSelected ( newItem, true);
itemSelected( newItem);
}
setLayoutDirty(parentItem);
}
void TreeView::del()
{
TreeItem *item = (TreeItem*)selectedItem();
// nil selected? -> nil to delete
if (item == 0) return;
del(item, true);
m_ac->action("edit_cut")->setEnabled(false);
m_ac->action("edit_copy")->setEnabled(false);
m_ac->action("delete")->setEnabled(false);
// Select new current item
setSelected( currentItem(), true );
// Switch the UI to show that item
itemSelected( selectedItem() );
}
void TreeView::del(TreeItem *item, bool deleteInfo)
{
TreeItem *parentItem = static_cast<TreeItem*>(item->parent());
// is file a .directory or a .desktop file
if(item->isDirectory())
{
MenuFolderInfo *folderInfo = item->folderInfo();
// Remove MenuFolderInfo
MenuFolderInfo *parentFolderInfo = parentItem ? parentItem->folderInfo() : m_rootFolder;
parentFolderInfo->take(folderInfo);
folderInfo->setInUse(false);
if (m_clipboard == COPY_FOLDER && (<API key> == folderInfo))
{
// Copy + Del == Cut
m_clipboard = MOVE_FOLDER; // Clipboard now owns folderInfo
}
else
{
if (folderInfo->takeRecursive(<API key>))
m_clipboard = MOVE_FOLDER; // Clipboard now owns <API key>
if (deleteInfo)
delete folderInfo; // Delete folderInfo
}
// Remove from menu
// m_menuFile->removeMenu(item->directory());
m_menuFile->pushAction(MenuFile::REMOVE_MENU, item->directory(), TQString::null);
// Remove tree item
delete item;
}
else if (item->isEntry())
{
MenuEntryInfo *entryInfo = item->entryInfo();
TQString menuId = entryInfo->menuId();
// Remove MenuFolderInfo
MenuFolderInfo *parentFolderInfo = parentItem ? parentItem->folderInfo() : m_rootFolder;
parentFolderInfo->take(entryInfo);
entryInfo->setInUse(false);
if (m_clipboard == COPY_FILE && (<API key> == entryInfo))
{
// Copy + Del == Cut
m_clipboard = MOVE_FILE; // Clipboard now owns entryInfo
}
else
{
if (deleteInfo)
delete entryInfo; // Delete entryInfo
}
// Remove from menu
TQString folder = parentItem ? parentItem->directory() : TQString::null;
// m_menuFile->removeEntry(folder, menuId);
m_menuFile->pushAction(MenuFile::REMOVE_ENTRY, folder, menuId);
// Remove tree item
delete item;
}
else
{
// Remove separator
delete item;
}
setLayoutDirty(parentItem);
}
void TreeView::cleanupClipboard() {
if (m_clipboard == MOVE_FOLDER)
delete <API key>;
<API key> = 0;
if (m_clipboard == MOVE_FILE)
delete <API key>;
<API key> = 0;
m_clipboard = 0;
}
static TQStringList extractLayout(TreeItem *item)
{
bool firstFolder = true;
bool firstEntry = true;
TQStringList layout;
for(;item; item = static_cast<TreeItem*>(item->nextSibling()))
{
if (item->isDirectory())
{
if (firstFolder)
{
firstFolder = false;
layout << ":M"; // Add new folders here...
}
layout << (item->folderInfo()->id);
}
else if (item->isEntry())
{
if (firstEntry)
{
firstEntry = false;
layout << ":F"; // Add new entries here...
}
layout << (item->entryInfo()->menuId());
}
else
{
layout << ":S";
}
}
return layout;
}
TQStringList TreeItem::layout()
{
TQStringList layout = extractLayout(static_cast<TreeItem*>(firstChild()));
_layoutDirty = false;
return layout;
}
void TreeView::saveLayout()
{
if (m_layoutDirty)
{
TQStringList layout = extractLayout(static_cast<TreeItem*>(firstChild()));
m_menuFile->setLayout(m_rootFolder->fullId, layout);
m_layoutDirty = false;
}
TQPtrList<TQListViewItem> lst;
<API key> it( this );
while ( it.current() ) {
TreeItem *item = static_cast<TreeItem*>(it.current());
if ( item->isLayoutDirty() )
{
m_menuFile->setLayout(item->folderInfo()->fullId, item->layout());
}
++it;
}
}
bool TreeView::save()
{
saveLayout();
m_rootFolder->save(m_menuFile);
bool success = m_menuFile->performAllActions();
m_newMenuIds.clear();
m_newDirectoryList.clear();
if (success)
{
KService::rebuildKSycoca(this);
}
else
{
KMessageBox::sorry(this, "<qt>"+i18n("Menu changes could not be saved because of the following problem:")+"<br><br>"+
m_menuFile->error()+"</qt>");
}
return success;
}
void TreeView::setLayoutDirty(TreeItem *parentItem)
{
if (parentItem)
parentItem->setLayoutDirty();
else
m_layoutDirty = true;
}
bool TreeView::isLayoutDirty()
{
TQPtrList<TQListViewItem> lst;
<API key> it( this );
while ( it.current() ) {
if ( static_cast<TreeItem*>(it.current())->isLayoutDirty() )
return true;
++it;
}
return false;
}
bool TreeView::dirty()
{
return m_layoutDirty || m_rootFolder->hasDirt() || m_menuFile->dirty() || isLayoutDirty();
}
void TreeView::findServiceShortcut(const TDEShortcut&cut, KService::Ptr &service)
{
service = m_rootFolder->findServiceShortcut(cut);
}
|
#include "drawingview.h"
#include <QApplication>
#include "randomgenerator.h"
#include "drawingcontroller.h"
#include "<API key>.h"
#include "lotwindow.h"
#include "app.h"
#include <QLibraryInfo>
#include <QTranslator>
#include "color.h"
#include "settingshandler.h"
#include "<API key>.h"
#include "updatereminder.h"
#include "updateview.h"
#include "i18n.h"
bool <API key>() {
QString langCountry = QLocale().system().name();
QString lang = langCountry.left(2);
if (lang == "nb" || lang == "nn") {
lang = "no";
}
bool langIsSupported = false;
for (int i = 0; i < NUM_LANGUAGES; ++i) {
if (LANGUAGES[i][1] == lang) {
langIsSupported = true;
}
}
if (langIsSupported) {
SettingsHandler::setLanguage(lang);
}
return langIsSupported;
}
int setupLanguage(QApplication& app) {
if (!SettingsHandler::hasLanguage()) {
bool ok = <API key>();
if (!ok) {
<API key> dialog;
if (dialog.exec() == QDialog::Rejected) {
return -1;
}
}
}
QString language = SettingsHandler::language();
if (language != "en") {
QTranslator* translator = new QTranslator();
QString filename = QString(language).append(".qm");
translator->load(filename, ":/app/translations");
app.installTranslator(translator);
}
return 0;
}
int main(int argc, char *argv[])
{
RandomGenerator::init();
<API key><Color>("Color");
QApplication app(argc, argv);
app.setApplicationName(APPLICATION_NAME);
app.<API key>(APPLICATION_NAME);
app.<API key>(APPLICATION_VERSION);
app.setOrganizationName(ORG_NAME);
app.<API key>(ORG_DOMAIN);
QIcon icon(":/gui/icons/lots.svg");
app.setWindowIcon(icon);
#ifdef Q_OS_MAC
app.setAttribute(Qt::<API key>, true);
#endif
SettingsHandler::initialize(ORG_NAME, APPLICATION_NAME);
if (int res = setupLanguage(app) != 0) {
return res;
}
<API key> setupController;
DrawingSetupDialog setupDialog(&setupController);
DrawingController controller;
DrawingView drawingView(&controller, &setupDialog);
controller.setDrawingView(&drawingView);
UpdateView updateView(&setupDialog);
UpdateReminder reminder([&](UpdateInfo info) {
if (!info.hasError && info.hasUpdate) {
updateView.setUpdateInfo(info);
updateView.show();
}
});
if (!SettingsHandler::autoUpdatesDisabled()) {
reminder.checkForUpdate();
}
return app.exec();
}
|
#include "../comedidev.h"
#include "comedi_pci.h"
#include "8255.h"
#define PCI_VENDOR_ID_CB 0x1307 /* PCI vendor number of ComputerBoards */
#define EEPROM_SIZE 128 /* number of entries in eeprom */
#define MAX_AO_CHANNELS 8 /* maximum number of ao channels for supported boards */
/* PCI-DDA base addresses */
#define DIGITALIO_BADRINDEX 2
/* DIGITAL I/O is pci_dev->resource[2] */
#define DIGITALIO_SIZE 8
/* DIGITAL I/O uses 8 I/O port addresses */
#define DAC_BADRINDEX 3
/* DAC is pci_dev->resource[3] */
/* Digital I/O registers */
#define PORT1A 0 /* PORT 1A DATA */
#define PORT1B 1 /* PORT 1B DATA */
#define PORT1C 2 /* PORT 1C DATA */
#define CONTROL1 3 /* CONTROL REGISTER 1 */
#define PORT2A 4 /* PORT 2A DATA */
#define PORT2B 5 /* PORT 2B DATA */
#define PORT2C 6 /* PORT 2C DATA */
#define CONTROL2 7 /* CONTROL REGISTER 2 */
/* DAC registers */
#define DACONTROL 0 /* D/A CONTROL REGISTER */
#define SU 0000001 /* Simultaneous update enabled */
#define NOSU 0000000 /* Simultaneous update disabled */
#define ENABLEDAC 0000002 /* Enable specified DAC */
#define DISABLEDAC 0000000 /* Disable specified DAC */
#define RANGE2V5 0000000 /* 2.5V */
#define RANGE5V 0000200
#define RANGE10V 0000300 /* 10V */
#define UNIP 0000400 /* Unipolar outputs */
#define BIP 0000000 /* Bipolar outputs */
#define DACALIBRATION1 4 /* D/A CALIBRATION REGISTER 1 */
/* write bits */
#define SERIAL_IN_BIT 0x1 /* serial data input for eeprom, caldacs, reference dac */
#define CAL_CHANNEL_MASK (0x7 << 1)
#define CAL_CHANNEL_BITS(channel) (((channel) << 1) & CAL_CHANNEL_MASK)
/* read bits */
#define CAL_COUNTER_MASK 0x1f
#define <API key> 0x20 /* calibration counter overflow status bit */
#define AO_BELOW_REF_BIT 0x40 /* analog output is less than reference dac voltage */
#define SERIAL_OUT_BIT 0x80 /* serial data out, for reading from eeprom */
#define DACALIBRATION2 6 /* D/A CALIBRATION REGISTER 2 */
#define SELECT_EEPROM_BIT 0x1 /* send serial data in to eeprom */
#define <API key> 0x2 /* don't send serial data to MAX542 reference dac */
#define DESELECT_CALDAC_BIT(n) (0x4 << (n)) /* don't send serial data to caldac n */
#define DUMMY_BIT 0x40 /* manual says to set this bit with no explanation */
#define DADATA 8 /* FIRST D/A DATA REGISTER (0) */
static const struct comedi_lrange cb_pcidda_ranges = {
6,
{
BIP_RANGE(10),
BIP_RANGE(5),
BIP_RANGE(2.5),
UNI_RANGE(10),
UNI_RANGE(5),
UNI_RANGE(2.5),
}
};
struct cb_pcidda_board {
const char *name;
char status; /* Driver status: */
/*
* 0 - tested
* 1 - manual read, not tested
* 2 - manual not read
*/
unsigned short device_id;
int ao_chans;
int ao_bits;
const struct comedi_lrange *ranges;
};
static const struct cb_pcidda_board cb_pcidda_boards[] = {
{
.name = "pci-dda02/12",
.status = 1,
.device_id = 0x20,
.ao_chans = 2,
.ao_bits = 12,
.ranges = &cb_pcidda_ranges,
},
{
.name = "pci-dda04/12",
.status = 1,
.device_id = 0x21,
.ao_chans = 4,
.ao_bits = 12,
.ranges = &cb_pcidda_ranges,
},
{
.name = "pci-dda08/12",
.status = 0,
.device_id = 0x22,
.ao_chans = 8,
.ao_bits = 12,
.ranges = &cb_pcidda_ranges,
},
{
.name = "pci-dda02/16",
.status = 2,
.device_id = 0x23,
.ao_chans = 2,
.ao_bits = 16,
.ranges = &cb_pcidda_ranges,
},
{
.name = "pci-dda04/16",
.status = 2,
.device_id = 0x24,
.ao_chans = 4,
.ao_bits = 16,
.ranges = &cb_pcidda_ranges,
},
{
.name = "pci-dda08/16",
.status = 0,
.device_id = 0x25,
.ao_chans = 8,
.ao_bits = 16,
.ranges = &cb_pcidda_ranges,
},
};
static <API key>(cb_pcidda_pci_table) = {
{
PCI_VENDOR_ID_CB, 0x0020, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
PCI_VENDOR_ID_CB, 0x0021, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
PCI_VENDOR_ID_CB, 0x0022, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
PCI_VENDOR_ID_CB, 0x0023, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
PCI_VENDOR_ID_CB, 0x0024, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
PCI_VENDOR_ID_CB, 0x0025, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
0}
};
MODULE_DEVICE_TABLE(pci, cb_pcidda_pci_table);
#define thisboard ((const struct cb_pcidda_board *)dev->board_ptr)
struct cb_pcidda_private {
int data;
/* would be useful for a PCI device */
struct pci_dev *pci_dev;
unsigned long digitalio;
unsigned long dac;
/* unsigned long control_status; */
/* unsigned long adc_fifo; */
unsigned int dac_cal1_bits; /* bits last written to da calibration register 1 */
unsigned int ao_range[MAX_AO_CHANNELS]; /* current range settings for output channels */
u16 eeprom_data[EEPROM_SIZE]; /* software copy of board's eeprom */
};
#define devpriv ((struct cb_pcidda_private *)dev->private)
static int cb_pcidda_attach(struct comedi_device *dev,
struct comedi_devconfig *it);
static int cb_pcidda_detach(struct comedi_device *dev);
/* static int cb_pcidda_ai_rinsn(struct comedi_device *dev,struct comedi_subdevice *s,struct comedi_insn *insn,unsigned int *data); */
static int cb_pcidda_ao_winsn(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data);
/* static int cb_pcidda_ai_cmd(struct comedi_device *dev, struct *comedi_subdevice *s);*/
/* static int <API key>(struct comedi_device *dev, struct comedi_subdevice *s, struct comedi_cmd *cmd); */
/* static int <API key>(unsigned int *ns,int *round); */
static unsigned int cb_pcidda_serial_in(struct comedi_device *dev);
static void <API key>(struct comedi_device *dev, unsigned int value,
unsigned int num_bits);
static unsigned int <API key>(struct comedi_device *dev,
unsigned int address);
static void cb_pcidda_calibrate(struct comedi_device *dev, unsigned int channel,
unsigned int range);
static struct comedi_driver driver_cb_pcidda = {
.driver_name = "cb_pcidda",
.module = THIS_MODULE,
.attach = cb_pcidda_attach,
.detach = cb_pcidda_detach,
};
static int cb_pcidda_attach(struct comedi_device *dev,
struct comedi_devconfig *it)
{
struct comedi_subdevice *s;
struct pci_dev *pcidev;
int index;
printk("comedi%d: cb_pcidda: ", dev->minor);
if (alloc_private(dev, sizeof(struct cb_pcidda_private)) < 0)
return -ENOMEM;
printk("\n");
for (pcidev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL);
pcidev != NULL;
pcidev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pcidev)) {
if (pcidev->vendor == PCI_VENDOR_ID_CB) {
if (it->options[0] || it->options[1]) {
if (pcidev->bus->number != it->options[0] ||
PCI_SLOT(pcidev->devfn) != it->options[1]) {
continue;
}
}
for (index = 0; index < ARRAY_SIZE(cb_pcidda_boards); index++) {
if (cb_pcidda_boards[index].device_id ==
pcidev->device) {
goto found;
}
}
}
}
if (!pcidev) {
printk
("Not a ComputerBoards/<API key> card on requested position\n");
return -EIO;
}
found:
devpriv->pci_dev = pcidev;
dev->board_ptr = cb_pcidda_boards + index;
/* "thisboard" macro can be used from here. */
printk("Found %s at requested position\n", thisboard->name);
/*
* Enable PCI device and request regions.
*/
if (comedi_pci_enable(pcidev, thisboard->name)) {
printk
("cb_pcidda: failed to enable PCI device and request regions\n");
return -EIO;
}
devpriv->digitalio =
pci_resource_start(devpriv->pci_dev, DIGITALIO_BADRINDEX);
devpriv->dac = pci_resource_start(devpriv->pci_dev, DAC_BADRINDEX);
if (thisboard->status == 2)
printk
("WARNING: DRIVER FOR THIS BOARD NOT CHECKED WITH MANUAL. "
"WORKS ASSUMING FULL COMPATIBILITY WITH PCI-DDA08/12. "
"PLEASE REPORT USAGE TO <ivanmr@altavista.com>.\n");
dev->board_name = thisboard->name;
if (alloc_subdevices(dev, 3) < 0)
return -ENOMEM;
s = dev->subdevices + 0;
/* analog output subdevice */
s->type = COMEDI_SUBD_AO;
s->subdev_flags = SDF_WRITABLE;
s->n_chan = thisboard->ao_chans;
s->maxdata = (1 << thisboard->ao_bits) - 1;
s->range_table = thisboard->ranges;
s->insn_write = cb_pcidda_ao_winsn;
/* s->subdev_flags |= SDF_CMD_READ; */
/* s->do_cmd = cb_pcidda_ai_cmd; */
/* s->do_cmdtest = <API key>; */
/* two 8255 digital io subdevices */
s = dev->subdevices + 1;
subdev_8255_init(dev, s, NULL, devpriv->digitalio);
s = dev->subdevices + 2;
subdev_8255_init(dev, s, NULL, devpriv->digitalio + PORT2A);
printk(" eeprom:");
for (index = 0; index < EEPROM_SIZE; index++) {
devpriv->eeprom_data[index] = <API key>(dev, index);
printk(" %i:0x%x ", index, devpriv->eeprom_data[index]);
}
printk("\n");
/* set calibrations dacs */
for (index = 0; index < thisboard->ao_chans; index++)
cb_pcidda_calibrate(dev, index, devpriv->ao_range[index]);
return 1;
}
static int cb_pcidda_detach(struct comedi_device *dev)
{
if (devpriv) {
if (devpriv->pci_dev) {
if (devpriv->dac)
comedi_pci_disable(devpriv->pci_dev);
pci_dev_put(devpriv->pci_dev);
}
}
/* cleanup 8255 */
if (dev->subdevices) {
subdev_8255_cleanup(dev, dev->subdevices + 1);
subdev_8255_cleanup(dev, dev->subdevices + 2);
}
printk("comedi%d: cb_pcidda: remove\n", dev->minor);
return 0;
}
#if 0
static int cb_pcidda_ai_cmd(struct comedi_device *dev,
struct comedi_subdevice *s)
{
printk("cb_pcidda_ai_cmd\n");
printk("subdev: %d\n", cmd->subdev);
printk("flags: %d\n", cmd->flags);
printk("start_src: %d\n", cmd->start_src);
printk("start_arg: %d\n", cmd->start_arg);
printk("scan_begin_src: %d\n", cmd->scan_begin_src);
printk("convert_src: %d\n", cmd->convert_src);
printk("convert_arg: %d\n", cmd->convert_arg);
printk("scan_end_src: %d\n", cmd->scan_end_src);
printk("scan_end_arg: %d\n", cmd->scan_end_arg);
printk("stop_src: %d\n", cmd->stop_src);
printk("stop_arg: %d\n", cmd->stop_arg);
printk("chanlist_len: %d\n", cmd->chanlist_len);
}
#endif
#if 0
static int <API key>(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_cmd *cmd)
{
int err = 0;
int tmp;
/* cmdtest tests a particular command to see if it is valid.
* Using the cmdtest ioctl, a user can create a valid cmd
* and then have it executes by the cmd ioctl.
*
* cmdtest returns 1,2,3,4 or 0, depending on which tests
* the command passes. */
/* step 1: make sure trigger sources are trivially valid */
tmp = cmd->start_src;
cmd->start_src &= TRIG_NOW;
if (!cmd->start_src || tmp != cmd->start_src)
err++;
tmp = cmd->scan_begin_src;
cmd->scan_begin_src &= TRIG_TIMER | TRIG_EXT;
if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
err++;
tmp = cmd->convert_src;
cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
if (!cmd->convert_src || tmp != cmd->convert_src)
err++;
tmp = cmd->scan_end_src;
cmd->scan_end_src &= TRIG_COUNT;
if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
err++;
tmp = cmd->stop_src;
cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
if (!cmd->stop_src || tmp != cmd->stop_src)
err++;
if (err)
return 1;
/* step 2: make sure trigger sources are unique and mutually compatible */
/* note that mutual compatibility is not an issue here */
if (cmd->scan_begin_src != TRIG_TIMER
&& cmd->scan_begin_src != TRIG_EXT)
err++;
if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT)
err++;
if (cmd->stop_src != TRIG_TIMER && cmd->stop_src != TRIG_EXT)
err++;
if (err)
return 2;
/* step 3: make sure arguments are trivially compatible */
if (cmd->start_arg != 0) {
cmd->start_arg = 0;
err++;
}
#define MAX_SPEED 10000 /* in nanoseconds */
#define MIN_SPEED 1000000000 /* in nanoseconds */
if (cmd->scan_begin_src == TRIG_TIMER) {
if (cmd->scan_begin_arg < MAX_SPEED) {
cmd->scan_begin_arg = MAX_SPEED;
err++;
}
if (cmd->scan_begin_arg > MIN_SPEED) {
cmd->scan_begin_arg = MIN_SPEED;
err++;
}
} else {
/* external trigger */
/* should be level/edge, hi/lo specification here */
/* should specify multiple external triggers */
if (cmd->scan_begin_arg > 9) {
cmd->scan_begin_arg = 9;
err++;
}
}
if (cmd->convert_src == TRIG_TIMER) {
if (cmd->convert_arg < MAX_SPEED) {
cmd->convert_arg = MAX_SPEED;
err++;
}
if (cmd->convert_arg > MIN_SPEED) {
cmd->convert_arg = MIN_SPEED;
err++;
}
} else {
/* external trigger */
/* see above */
if (cmd->convert_arg > 9) {
cmd->convert_arg = 9;
err++;
}
}
if (cmd->scan_end_arg != cmd->chanlist_len) {
cmd->scan_end_arg = cmd->chanlist_len;
err++;
}
if (cmd->stop_src == TRIG_COUNT) {
if (cmd->stop_arg > 0x00ffffff) {
cmd->stop_arg = 0x00ffffff;
err++;
}
} else {
/* TRIG_NONE */
if (cmd->stop_arg != 0) {
cmd->stop_arg = 0;
err++;
}
}
if (err)
return 3;
/* step 4: fix up any arguments */
if (cmd->scan_begin_src == TRIG_TIMER) {
tmp = cmd->scan_begin_arg;
<API key>(&cmd->scan_begin_arg,
cmd->flags & TRIG_ROUND_MASK);
if (tmp != cmd->scan_begin_arg)
err++;
}
if (cmd->convert_src == TRIG_TIMER) {
tmp = cmd->convert_arg;
<API key>(&cmd->convert_arg,
cmd->flags & TRIG_ROUND_MASK);
if (tmp != cmd->convert_arg)
err++;
if (cmd->scan_begin_src == TRIG_TIMER &&
cmd->scan_begin_arg <
cmd->convert_arg * cmd->scan_end_arg) {
cmd->scan_begin_arg =
cmd->convert_arg * cmd->scan_end_arg;
err++;
}
}
if (err)
return 4;
return 0;
}
#endif
#if 0
static int <API key>(unsigned int *ns, int round)
{
/* trivial timer */
return *ns;
}
#endif
static int cb_pcidda_ao_winsn(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
unsigned int command;
unsigned int channel, range;
channel = CR_CHAN(insn->chanspec);
range = CR_RANGE(insn->chanspec);
/* adjust calibration dacs if range has changed */
if (range != devpriv->ao_range[channel])
cb_pcidda_calibrate(dev, channel, range);
/* output channel configuration */
command = NOSU | ENABLEDAC;
/* output channel range */
switch (range) {
case 0:
command |= BIP | RANGE10V;
break;
case 1:
command |= BIP | RANGE5V;
break;
case 2:
command |= BIP | RANGE2V5;
break;
case 3:
command |= UNIP | RANGE10V;
break;
case 4:
command |= UNIP | RANGE5V;
break;
case 5:
command |= UNIP | RANGE2V5;
break;
};
/* output channel specification */
command |= channel << 2;
outw(command, devpriv->dac + DACONTROL);
/* write data */
outw(data[0], devpriv->dac + DADATA + channel * 2);
/* return the number of samples read/written */
return 1;
}
/* lowlevel read from eeprom */
static unsigned int cb_pcidda_serial_in(struct comedi_device *dev)
{
unsigned int value = 0;
int i;
const int value_width = 16; /* number of bits wide values are */
for (i = 1; i <= value_width; i++) {
/* read bits most significant bit first */
if (inw_p(devpriv->dac + DACALIBRATION1) & SERIAL_OUT_BIT)
value |= 1 << (value_width - i);
}
return value;
}
/* lowlevel write to eeprom/dac */
static void <API key>(struct comedi_device *dev, unsigned int value,
unsigned int num_bits)
{
int i;
for (i = 1; i <= num_bits; i++) {
/* send bits most significant bit first */
if (value & (1 << (num_bits - i)))
devpriv->dac_cal1_bits |= SERIAL_IN_BIT;
else
devpriv->dac_cal1_bits &= ~SERIAL_IN_BIT;
outw_p(devpriv->dac_cal1_bits, devpriv->dac + DACALIBRATION1);
}
}
/* reads a 16 bit value from board's eeprom */
static unsigned int <API key>(struct comedi_device *dev,
unsigned int address)
{
unsigned int i;
unsigned int cal2_bits;
unsigned int value;
const int max_num_caldacs = 4; /* one caldac for every two dac channels */
const int read_instruction = 0x6; /* bits to send to tell eeprom we want to read */
const int instruction_length = 3;
const int address_length = 8;
/* send serial output stream to eeprom */
cal2_bits = SELECT_EEPROM_BIT | <API key> | DUMMY_BIT;
/* deactivate caldacs (one caldac for every two channels) */
for (i = 0; i < max_num_caldacs; i++)
cal2_bits |= DESELECT_CALDAC_BIT(i);
outw_p(cal2_bits, devpriv->dac + DACALIBRATION2);
/* tell eeprom we want to read */
<API key>(dev, read_instruction, instruction_length);
/* send address we want to read from */
<API key>(dev, address, address_length);
value = cb_pcidda_serial_in(dev);
/* deactivate eeprom */
cal2_bits &= ~SELECT_EEPROM_BIT;
outw_p(cal2_bits, devpriv->dac + DACALIBRATION2);
return value;
}
/* writes to 8 bit calibration dacs */
static void <API key>(struct comedi_device *dev,
unsigned int caldac, unsigned int channel,
unsigned int value)
{
unsigned int cal2_bits;
unsigned int i;
const int num_channel_bits = 3; /* caldacs use 3 bit channel specification */
const int num_caldac_bits = 8; /* 8 bit calibration dacs */
const int max_num_caldacs = 4; /* one caldac for every two dac channels */
/* write 3 bit channel */
<API key>(dev, channel, num_channel_bits);
/* write 8 bit caldac value */
<API key>(dev, value, num_caldac_bits);
cal2_bits = <API key> | DUMMY_BIT;
/* deactivate caldacs (one caldac for every two channels) */
for (i = 0; i < max_num_caldacs; i++)
cal2_bits |= DESELECT_CALDAC_BIT(i);
/* activate the caldac we want */
cal2_bits &= ~DESELECT_CALDAC_BIT(caldac);
outw_p(cal2_bits, devpriv->dac + DACALIBRATION2);
/* deactivate caldac */
cal2_bits |= DESELECT_CALDAC_BIT(caldac);
outw_p(cal2_bits, devpriv->dac + DACALIBRATION2);
}
/* returns caldac that calibrates given analog out channel */
static unsigned int caldac_number(unsigned int channel)
{
return channel / 2;
}
/* returns caldac channel that provides fine gain for given ao channel */
static unsigned int fine_gain_channel(unsigned int ao_channel)
{
return 4 * (ao_channel % 2);
}
/* returns caldac channel that provides coarse gain for given ao channel */
static unsigned int coarse_gain_channel(unsigned int ao_channel)
{
return 1 + 4 * (ao_channel % 2);
}
/* returns caldac channel that provides coarse offset for given ao channel */
static unsigned int <API key>(unsigned int ao_channel)
{
return 2 + 4 * (ao_channel % 2);
}
/* returns caldac channel that provides fine offset for given ao channel */
static unsigned int fine_offset_channel(unsigned int ao_channel)
{
return 3 + 4 * (ao_channel % 2);
}
/* returns eeprom address that provides offset for given ao channel and range */
static unsigned int <API key>(unsigned int ao_channel,
unsigned int range)
{
return 0x7 + 2 * range + 12 * ao_channel;
}
/* returns eeprom address that provides gain calibration for given ao channel and range */
static unsigned int gain_eeprom_address(unsigned int ao_channel,
unsigned int range)
{
return 0x8 + 2 * range + 12 * ao_channel;
}
/* returns upper byte of eeprom entry, which gives the coarse adjustment values */
static unsigned int eeprom_coarse_byte(unsigned int word)
{
return (word >> 8) & 0xff;
}
/* returns lower byte of eeprom entry, which gives the fine adjustment values */
static unsigned int eeprom_fine_byte(unsigned int word)
{
return word & 0xff;
}
/* set caldacs to eeprom values for given channel and range */
static void cb_pcidda_calibrate(struct comedi_device *dev, unsigned int channel,
unsigned int range)
{
unsigned int coarse_offset, fine_offset, coarse_gain, fine_gain;
/* remember range so we can tell when we need to readjust calibration */
devpriv->ao_range[channel] = range;
/* get values from eeprom data */
coarse_offset =
eeprom_coarse_byte(devpriv->eeprom_data
[<API key>(channel, range)]);
fine_offset =
eeprom_fine_byte(devpriv->eeprom_data
[<API key>(channel, range)]);
coarse_gain =
eeprom_coarse_byte(devpriv->eeprom_data
[gain_eeprom_address(channel, range)]);
fine_gain =
eeprom_fine_byte(devpriv->eeprom_data
[gain_eeprom_address(channel, range)]);
/* set caldacs */
<API key>(dev, caldac_number(channel),
<API key>(channel), coarse_offset);
<API key>(dev, caldac_number(channel),
fine_offset_channel(channel), fine_offset);
<API key>(dev, caldac_number(channel),
coarse_gain_channel(channel), coarse_gain);
<API key>(dev, caldac_number(channel),
fine_gain_channel(channel), fine_gain);
}
<API key>(driver_cb_pcidda, cb_pcidda_pci_table);
|
#ifndef <API key>
#define <API key>
#include <linux/transport_class.h>
#include <linux/types.h>
#include <linux/mutex.h>
#define <API key> 0
#define <API key> 1
struct <API key> {
u8 port_id[16];
u8 roles;
};
struct srp_rport {
struct device dev;
u8 port_id[16];
u8 roles;
};
struct <API key> {
/* for target drivers */
int (* tsk_mgmt_response)(struct Scsi_Host *, u64, u64, int);
int (* it_nexus_response)(struct Scsi_Host *, u64, int);
};
extern struct <API key> *
<API key>(struct <API key> *);
extern void <API key>(struct <API key> *);
extern struct srp_rport *srp_rport_add(struct Scsi_Host *,
struct <API key> *);
extern void srp_rport_del(struct srp_rport *);
extern void srp_remove_host(struct Scsi_Host *);
#endif
|
/** @version 6.0 */
/** This file is part of SdS - Sistema della Sicurezza . */
/** SdS - Sistema della Sicurezza is free software: you can redistribute it and/or modify */
/** (at your option) any later version. */
/** SdS - Sistema della Sicurezza is distributed in the hope that it will be useful, */
/** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package com.apconsulting.luna.ejb.Corsi;
/**
*
* @author Dario
*/
public class MaterialeCorso_View implements java.io.Serializable {
public long COD_DOC;
public String TIT_DOC;
public java.sql.Date DAT_REV_DOC;
public String RSP_DOC;
public String NOME_FILE;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.